Commited patch in issue #8171 (by darktjm).

git-svn-id: https://pcsxr.svn.codeplex.com/svn/pcsxr@64524 e17a0e51-4ae3-4d35-97c3-1a29b211df97

33 files changed, 3873 insertions, 3618 deletions

diff --git a/libpcsxcore/cdriso.c b/libpcsxcore/cdriso.c
index 4a4982c7..4ecf5eee 100644
--- a/libpcsxcore/cdriso.c
+++ b/libpcsxcore/cdriso.c
@@ -44,12 +44,12 @@ static unsigned char subbuffer[SUB_FRAMESIZE];
 static unsigned char sndbuffer[CD_FRAMESIZE_RAW * 10];
 
 #define CDDA_FRAMETIME			(1000 * (sizeof(sndbuffer) / CD_FRAMESIZE_RAW) / 75)
-

-

-#define MODE1_DATA_SIZE			2048

-

-static boolean isMode1ISO = FALSE;

-

+
+
+#define MODE1_DATA_SIZE			2048
+
+static boolean isMode1ISO = FALSE;
+
 
 #ifdef _WIN32
 static HANDLE threadid;
@@ -61,15 +61,6 @@ static volatile boolean playing = FALSE;
 static boolean cddaBigEndian = FALSE;
 static volatile unsigned int cddaCurOffset = 0;
 
-char* CALLBACK CDR__getDriveLetter(void);
-long CALLBACK CDR__configure(void);
-long CALLBACK CDR__test(void);
-void CALLBACK CDR__about(void);
-long CALLBACK CDR__setfilename(char *filename);
-long CALLBACK CDR__getStatus(struct CdrStat *stat);
-
-extern void *hCDRDriver;
-
 struct trackinfo {
 	enum {DATA=1, CDDA} type;
 	u8 start[3];		// MSF-format
@@ -82,11 +73,11 @@ static int numtracks = 0;
 static struct trackinfo ti[MAXTRACKS];
 
 // get a sector from a msf-array
-unsigned int msf2sec(char *msf) {
+unsigned int msf2sec(u8 *msf) {
 	return ((msf[0] * 60 + msf[1]) * 75) + msf[2];
 }
 
-void sec2msf(unsigned int s, char *msf) {
+void sec2msf(unsigned int s, u8 *msf) {
 	msf[0] = s / 75 / 60;
 	s = s - msf[0] * 75 * 60;
 	msf[1] = s / 75;
@@ -95,7 +86,7 @@ void sec2msf(unsigned int s, char *msf) {
 }
 
 // divide a string of xx:yy:zz into m, s, f
-static void tok2msf(char *time, char *msf) {
+static void tok2msf(char *time, u8 *msf) {
 	char *token;
 
 	token = strtok(time, ":");
@@ -187,7 +178,8 @@ static void *playthread(void *param)
 
 				s += d;
 
-				fread( subbuffer, 1, SUB_FRAMESIZE, cddaHandle );
+				if(fread( subbuffer, SUB_FRAMESIZE, 1, cddaHandle ) != 1)
+					perror("cdr sub read");
 			}
 		}
 		else {
@@ -195,9 +187,10 @@ static void *playthread(void *param)
 
 			sec = cddaCurOffset / CD_FRAMESIZE_RAW;
 
-			if (subHandle != NULL) {
-				fseek(subHandle, sec * SUB_FRAMESIZE, SEEK_SET);
-				fread(subbuffer, 1, SUB_FRAMESIZE, subHandle);
+			if (s && subHandle != NULL) {
+				if(fseek(subHandle, sec * SUB_FRAMESIZE, SEEK_SET) < 0 ||
+				   fread(subbuffer, SUB_FRAMESIZE, 1, subHandle) != 1)
+					perror("cdr sub read");
 			}
 		}
 
@@ -269,7 +262,7 @@ static void *playthread(void *param)
 
 	
 		// Vib Ribbon: decoded buffer IRQ
-		iso_play_cdbuf = sndbuffer;
+		iso_play_cdbuf = (u16 *)sndbuffer;
 		iso_play_bufptr = 0;
 	}
 
@@ -406,21 +399,21 @@ static int parsetoc(const char *isofile) {
 				sscanf(linebuf, "DATAFILE \"%[^\"]\" #%d %8s", name, &t, time2);
 				t /= CD_FRAMESIZE_RAW + (subChanMixed ? SUB_FRAMESIZE : 0);
 				t += 2 * 75;
-				sec2msf(t, (char *)&ti[numtracks].start);
-				tok2msf((char *)&time2, (char *)&ti[numtracks].length);
+				sec2msf(t, (u8 *)&ti[numtracks].start);
+				tok2msf((char *)&time2, (u8 *)&ti[numtracks].length);
 			}
 			else {
 				sscanf(linebuf, "DATAFILE \"%[^\"]\" %8s", name, time);
-				tok2msf((char *)&time, (char *)&ti[numtracks].length);
+				tok2msf((char *)&time, (u8 *)&ti[numtracks].length);
 			}
 		}
 		else if (!strcmp(token, "FILE")) {
 			sscanf(linebuf, "FILE \"%[^\"]\" #%d %8s %8s", name, &t, time, time2);
-			tok2msf((char *)&time, (char *)&ti[numtracks].start);
+			tok2msf((char *)&time, (u8 *)&ti[numtracks].start);
 			t /= CD_FRAMESIZE_RAW + (subChanMixed ? SUB_FRAMESIZE : 0);
-			t += msf2sec(ti[numtracks].start) + 2 * 75;
-			sec2msf(t, (char *)&ti[numtracks].start);
-			tok2msf((char *)&time2, (char *)&ti[numtracks].length);
+			t += msf2sec((u8 *)&ti[numtracks].start) + 2 * 75;
+			sec2msf(t, (u8 *)&ti[numtracks].start);
+			tok2msf((char *)&time2, (u8 *)&ti[numtracks].length);
 		}
 	}
 
@@ -497,10 +490,10 @@ static int parsecue(const char *isofile) {
 				if (*tmp != '\n') sscanf(tmp, "%8s", time);
 			}
 
-			tok2msf((char *)&time, (char *)&ti[numtracks].start);
+			tok2msf((char *)&time, (u8 *)&ti[numtracks].start);
 
-			t = msf2sec(ti[numtracks].start) + 2 * 75;
-			sec2msf(t, ti[numtracks].start);
+			t = msf2sec((u8 *)&ti[numtracks].start) + 2 * 75;
+			sec2msf(t, (u8 *)&ti[numtracks].start);
 
 			// If we've already seen another track, this is its end
 			if (numtracks > 1) {
@@ -607,29 +600,37 @@ static int parsemds(const char *isofile) {
 	memset(&ti, 0, sizeof(ti));
 
 	// check if it's a valid mds file
-	fread(&i, 1, sizeof(unsigned int), fi);
-	i = SWAP32(i);
-	if (i != 0x4944454D) {
+	if(fread(&i, sizeof(unsigned int), 1, fi) != 1 ||
+	   SWAP32(i) != 0x4944454D) {
 		// not an valid mds file
 		fclose(fi);
 		return -1;
 	}
 
 	// get offset to session block
-	fseek(fi, 0x50, SEEK_SET);
-	fread(&offset, 1, sizeof(unsigned int), fi);
+	if(fseek(fi, 0x50, SEEK_SET) < 0 ||
+	   fread(&offset, sizeof(unsigned int), 1, fi) != 1) {
+		fclose(fi);
+		return -1;
+	}
 	offset = SWAP32(offset);
 
 	// get total number of tracks
 	offset += 14;
-	fseek(fi, offset, SEEK_SET);
-	fread(&s, 1, sizeof(unsigned short), fi);
+	if(fseek(fi, offset, SEEK_SET) < 0 ||
+	   fread(&s, sizeof(unsigned short), 1, fi) != 1) {
+		fclose(fi);
+		return -1;
+	}
 	s = SWAP16(s);
 	numtracks = s;
 
 	// get offset to track blocks
-	fseek(fi, 4, SEEK_CUR);
-	fread(&offset, 1, sizeof(unsigned int), fi);
+	if(fseek(fi, 4, SEEK_CUR) < 0 ||
+	   fread(&offset, sizeof(unsigned int), 1, fi) != 1) {
+		fclose(fi);
+		return -1;
+	}
 	offset = SWAP32(offset);
 
 	// skip lead-in data
@@ -664,11 +665,17 @@ static int parsemds(const char *isofile) {
 		}
 
 		// get the track length
-		fread(&extra_offset, 1, sizeof(unsigned int), fi);
+		if(fread(&extra_offset, sizeof(unsigned int), 1, fi) != 1) {
+			fclose(fi);
+			return -1;
+		}
 		extra_offset = SWAP32(extra_offset);
 
-		fseek(fi, extra_offset + 4, SEEK_SET);
-		fread(&l, 1, sizeof(unsigned int), fi);
+		if(fseek(fi, extra_offset + 4, SEEK_SET) < 0 ||
+		   fread(&l, sizeof(unsigned int), 1, fi)) {
+			fclose(fi);
+			return -1;
+		}
 		l = SWAP32(l);
 		sec2msf(l, ti[i].length);
 
@@ -735,8 +742,8 @@ static void PrintTracks(void) {
 // This function is invoked by the front-end when opening an ISO
 // file for playback
 static long CALLBACK ISOopen(void) {
-	u32 modeTest = 0;

-

+	u32 modeTest = 0;
+
 	if (cdHandle != NULL) {
 		return 0; // it's already open
 	}
@@ -750,7 +757,7 @@ static long CALLBACK ISOopen(void) {
 
 	cddaBigEndian = FALSE;
 	subChanMixed = FALSE;
-	subChanRaw = FALSE;

+	subChanRaw = FALSE;
 	isMode1ISO = FALSE;
 
 	if (parseccd(GetIsoFile()) == 0) {
@@ -764,21 +771,21 @@ static long CALLBACK ISOopen(void) {
 	}
 	else if (parsetoc(GetIsoFile()) == 0) {
 		SysPrintf("[+toc]");
-	} else {

-		//guess whether it is mode1/2048

-		fseek(cdHandle, 0, SEEK_END);

-		if(ftell(cdHandle) % 2048 == 0) {

-			fseek(cdHandle, 0, SEEK_SET);

-			fread(&modeTest, 4, 1, cdHandle);

-			if(SWAP32(modeTest)!=0xffffff00) isMode1ISO = TRUE;

-		}

-		fseek(cdHandle, 0, SEEK_SET);

-	}

+	} else {
+		//guess whether it is mode1/2048
+		fseek(cdHandle, 0, SEEK_END);
+		if(ftell(cdHandle) % 2048 == 0) {
+			if(fseek(cdHandle, 0, SEEK_SET) >= 0 &&
+			   fread(&modeTest, 4, 1, cdHandle) == 1 &&
+			   SWAP32(modeTest)!=0xffffff00) isMode1ISO = TRUE;
+		}
+		fseek(cdHandle, 0, SEEK_SET);
+	}
 
 	if (!subChanMixed && opensubfile(GetIsoFile()) == 0) {
 		SysPrintf("[+sub]");
 	}
-

+
 	SysPrintf(".\n");
 
 	PrintTracks();
@@ -880,29 +887,33 @@ static long CALLBACK ISOreadTrack(unsigned char *time) {
 	}
 
 	if (subChanMixed) {
-		fseek(cdHandle, MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2])) * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE), SEEK_SET);
-		fread(cdbuffer, 1, CD_FRAMESIZE_RAW, cdHandle);
-		fread(subbuffer, 1, SUB_FRAMESIZE, cdHandle);
+		if(fseek(cdHandle, MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2])) * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE), SEEK_SET) < 0 ||
+		   fread(cdbuffer, CD_FRAMESIZE_RAW, 1, cdHandle) != 1 ||
+		   fread(subbuffer, SUB_FRAMESIZE, 1, cdHandle) != 1)
+			return -1;
 
 		if (subChanRaw) DecodeRawSubData();
 	}
-	else {

-		if(isMode1ISO) {

-			fseek(cdHandle, MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2])) * MODE1_DATA_SIZE, SEEK_SET);

-			fread(cdbuffer + 12, 1, MODE1_DATA_SIZE, cdHandle);

-			memset(cdbuffer, 0, 12); //not really necessary, fake mode 2 header

-			cdbuffer[0] = (time[0]);

-			cdbuffer[1] = (time[1]);

-			cdbuffer[2] = (time[2]);

-			cdbuffer[3] = 1; //mode 1

+	else {
+		if(isMode1ISO) {
+			if(fseek(cdHandle, MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2])) * MODE1_DATA_SIZE, SEEK_SET) < 0 ||
+			   fread(cdbuffer + 12, MODE1_DATA_SIZE, 1, cdHandle) != 1)
+				return -1;
+			memset(cdbuffer, 0, 12); //not really necessary, fake mode 2 header
+			cdbuffer[0] = (time[0]);
+			cdbuffer[1] = (time[1]);
+			cdbuffer[2] = (time[2]);
+			cdbuffer[3] = 1; //mode 1
 		} else {
-			fseek(cdHandle, MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2])) * CD_FRAMESIZE_RAW, SEEK_SET);
-			fread(cdbuffer, 1, CD_FRAMESIZE_RAW, cdHandle);

+			if(fseek(cdHandle, MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2])) * CD_FRAMESIZE_RAW, SEEK_SET) < 0 ||
+			   fread(cdbuffer, CD_FRAMESIZE_RAW, 1, cdHandle) != 1)
+				return -1;
 		}
 
 		if (subHandle != NULL) {
-			fseek(subHandle, MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2])) * SUB_FRAMESIZE, SEEK_SET);
-			fread(subbuffer, 1, SUB_FRAMESIZE, subHandle);
+			if(fseek(subHandle, MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2])) * SUB_FRAMESIZE, SEEK_SET) < 0 ||
+			   fread(subbuffer, SUB_FRAMESIZE, 1, subHandle) != 1)
+				return -1;
 
 			if (subChanRaw) DecodeRawSubData();
 		}
@@ -963,37 +974,37 @@ static long CALLBACK ISOgetStatus(struct CdrStat *stat) {
 	stat->Type = ti[1].type;
 	
 	return 0;
-}

-

-// read CDDA sector into buffer

-long CALLBACK ISOreadCDDA(unsigned char m, unsigned char s, unsigned char f, unsigned char *buffer) {

-	unsigned char msf[3] = {m, s, f};

-	unsigned char *p;

-

-	msf[0] = itob(msf[0]);

-	msf[1] = itob(msf[1]);

-	msf[2] = itob(msf[2]);

-

-	if (ISOreadTrack(msf) != 0) return -1;

-

-	p = ISOgetBuffer();

-	if (p == NULL) return -1;

-

-	memcpy(buffer, p - 12, CD_FRAMESIZE_RAW); // copy from the beginning of the sector

-

-	if (cddaBigEndian) {

-		int i;

-		unsigned char tmp;

-

+}
+
+// read CDDA sector into buffer
+static long CALLBACK ISOreadCDDA(unsigned char m, unsigned char s, unsigned char f, unsigned char *buffer) {
+	unsigned char msf[3] = {m, s, f};
+	unsigned char *p;
+
+	msf[0] = itob(msf[0]);
+	msf[1] = itob(msf[1]);
+	msf[2] = itob(msf[2]);
+
+	if (ISOreadTrack(msf) != 0) return -1;
+
+	p = ISOgetBuffer();
+	if (p == NULL) return -1;
+
+	memcpy(buffer, p - 12, CD_FRAMESIZE_RAW); // copy from the beginning of the sector
+
+	if (cddaBigEndian) {
+		int i;
+		unsigned char tmp;
+
 		for (i = 0; i < CD_FRAMESIZE_RAW / 2; i++) {
 			tmp = buffer[i * 2];
 			buffer[i * 2] = buffer[i * 2 + 1];
 			buffer[i * 2 + 1] = tmp;
 		}
-	}

-

-	return 0;

-}

+	}
+
+	return 0;
+}
 
 void cdrIsoInit(void) {
 	CDR_init = ISOinit;
@@ -1008,7 +1019,7 @@ void cdrIsoInit(void) {
 	CDR_stop = ISOstop;
 	CDR_getBufferSub = ISOgetBufferSub;
 	CDR_getStatus = ISOgetStatus;
-	CDR_readCDDA = ISOreadCDDA;

+	CDR_readCDDA = ISOreadCDDA;
 
 	CDR_getDriveLetter = CDR__getDriveLetter;
 	CDR_configure = CDR__configure;
diff --git a/libpcsxcore/cdriso.h b/libpcsxcore/cdriso.h
index 27d1ecd0..dfa863d9 100644
--- a/libpcsxcore/cdriso.h
+++ b/libpcsxcore/cdriso.h
@@ -28,6 +28,14 @@ extern "C" {
 void cdrIsoInit(void);
 int cdrIsoActive(void);
 
+unsigned int msf2sec(u8 *msf);
+void sec2msf(unsigned int s, u8 *msf);
+
+extern u16 *iso_play_cdbuf;
+extern u16 iso_play_bufptr;
+
+long CALLBACK ISOinit(void);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c
index b49d0358..4be39d22 100644
--- a/libpcsxcore/cdrom.c
+++ b/libpcsxcore/cdrom.c
@@ -22,8 +22,10 @@
 */
 
 #include "cdrom.h"
+#include "cdriso.h"
 #include "ppf.h"
 #include "psxdma.h"
+#include "spu.h"
 
 cdrStruct cdr;
 
@@ -91,29 +93,29 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 #define Acknowledge	3
 #define DataEnd		4
 #define DiskError	5
-

-/* Modes flags */

-#define MODE_SPEED       (1<<7) // 0x80

-#define MODE_STRSND      (1<<6) // 0x40 ADPCM on/off

-#define MODE_SIZE_2340   (1<<5) // 0x20

-#define MODE_SIZE_2328   (1<<4) // 0x10

-#define MODE_SIZE_2048   (0<<4) // 0x00

-#define MODE_SF          (1<<3) // 0x08 channel on/off

-#define MODE_REPORT      (1<<2) // 0x04

-#define MODE_AUTOPAUSE   (1<<1) // 0x02

-#define MODE_CDDA        (1<<0) // 0x01

-

-/* Status flags */

-#define STATUS_PLAY      (1<<7) // 0x80

-#define STATUS_SEEK      (1<<6) // 0x40

-#define STATUS_READ      (1<<5) // 0x20

-#define STATUS_SHELLOPEN (1<<4) // 0x10

-#define STATUS_UNKNOWN3  (1<<3) // 0x08

-#define STATUS_UNKNOWN2  (1<<2) // 0x04

-#define STATUS_ROTATING  (1<<1) // 0x02

-#define STATUS_ERROR     (1<<0) // 0x01

-

-

+
+/* Modes flags */
+#define MODE_SPEED       (1<<7) // 0x80
+#define MODE_STRSND      (1<<6) // 0x40 ADPCM on/off
+#define MODE_SIZE_2340   (1<<5) // 0x20
+#define MODE_SIZE_2328   (1<<4) // 0x10
+#define MODE_SIZE_2048   (0<<4) // 0x00
+#define MODE_SF          (1<<3) // 0x08 channel on/off
+#define MODE_REPORT      (1<<2) // 0x04
+#define MODE_AUTOPAUSE   (1<<1) // 0x02
+#define MODE_CDDA        (1<<0) // 0x01
+
+/* Status flags */
+#define STATUS_PLAY      (1<<7) // 0x80
+#define STATUS_SEEK      (1<<6) // 0x40
+#define STATUS_READ      (1<<5) // 0x20
+#define STATUS_SHELLOPEN (1<<4) // 0x10
+#define STATUS_UNKNOWN3  (1<<3) // 0x08
+#define STATUS_UNKNOWN2  (1<<2) // 0x04
+#define STATUS_ROTATING  (1<<1) // 0x02
+#define STATUS_ERROR     (1<<0) // 0x01
+
+
 
 // 1x = 75 sectors per second
 // PSXCLK = 1 sec in the ps
@@ -122,21 +124,12 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 
 static struct CdrStat stat;
 static struct SubQ *subq;
-

-

-extern unsigned int msf2sec(char *msf);

-extern void sec2msf(unsigned int s, char *msf);

-
-
-extern u16 *iso_play_cdbuf;
-extern u16 iso_play_bufptr;
-extern long CALLBACK ISOinit(void);
-extern void CALLBACK SPUirq(void);
-extern SPUregisterCallback SPU_registerCallback;
 
+#ifndef H_SPUirqAddr
 #define H_SPUirqAddr		0x1f801da4
 #define H_SPUaddr				0x1f801da6
 #define H_SPUctrl				0x1f801daa
+#endif
 #define H_CDLeft				0x1f801db0
 #define H_CDRight				0x1f801db2
 
@@ -165,12 +158,12 @@ extern SPUregisterCallback SPU_registerCallback;
 	psxRegs.intCycle[PSXINT_CDRLID].sCycle = psxRegs.cycle; \
 }
 
-#define CDRPLAY_INT(eCycle) { \

-	psxRegs.interrupt |= (1 << PSXINT_CDRPLAY); \

-	psxRegs.intCycle[PSXINT_CDRPLAY].cycle = eCycle; \

-	psxRegs.intCycle[PSXINT_CDRPLAY].sCycle = psxRegs.cycle; \

-}

-

+#define CDRPLAY_INT(eCycle) { \
+	psxRegs.interrupt |= (1 << PSXINT_CDRPLAY); \
+	psxRegs.intCycle[PSXINT_CDRPLAY].cycle = eCycle; \
+	psxRegs.intCycle[PSXINT_CDRPLAY].sCycle = psxRegs.cycle; \
+}
+
 #define StartReading(type, eCycle) { \
    	cdr.Reading = type; \
   	cdr.FirstSector = 1; \
@@ -193,7 +186,7 @@ extern SPUregisterCallback SPU_registerCallback;
 		cdr.Play = FALSE; \
 		cdr.FastForward = 0; \
 		cdr.FastBackward = 0; \
-		SPU_registerCallback( SPUirq ); \

+		SPU_registerCallback( SPUirq ); \
 	} \
 }
 
@@ -206,11 +199,11 @@ extern SPUregisterCallback SPU_registerCallback;
 
 void cdrDecodedBufferInterrupt()
 {
-	u16 buf_ptr[0x400], lcv;

-

-#if 0

-	return;

-#endif

+	u16 buf_ptr[0x400], lcv;
+
+#if 0
+	return;
+#endif
 
 
 	// ISO reader only
@@ -329,7 +322,7 @@ void cdrLidSeekInterrupt()
 }
 
 
-void Check_Shell( int Irq )
+static void Check_Shell( int Irq )
 {
 	// check case open/close
 	if (cdr.LidCheck > 0)
@@ -346,7 +339,7 @@ void Check_Shell( int Irq )
 			i = stat.Status;
 			if (CDR_getStatus(&stat) != -1)
 			{
-				// BIOS hangs + BIOS error messages

+				// BIOS hangs + BIOS error messages
 				//if (stat.Type == 0xff)
 					//cdr.Stat = DiskError;
 
@@ -439,7 +432,7 @@ void Check_Shell( int Irq )
 }
 
 
-void Find_CurTrack() {
+static void Find_CurTrack() {
 	cdr.CurTrack = 0;
 
 	if (CDR_getTN(cdr.ResultTN) != -1) {
@@ -459,11 +452,11 @@ void Find_CurTrack() {
 				// find next track boundary - only need m:s accuracy
 				sect1 = cdr.SetSectorPlay[0] * 60 * 75 + cdr.SetSectorPlay[1] * 75;
 				sect2 = cdr.ResultTD[2] * 60 * 75 + cdr.ResultTD[1] * 75;
-

-				// Twisted Metal 4 - psx cdda pregap (2-sec)

-				// - fix in-game music

-				sect2 -= 75 * 2;

-

+
+				// Twisted Metal 4 - psx cdda pregap (2-sec)
+				// - fix in-game music
+				sect2 -= 75 * 2;
+
 				if( sect1 >= sect2 ) {
 					cdr.CurTrack++;
 					continue;
@@ -486,50 +479,50 @@ static void ReadTrack( u8 *time ) {
 	cdr.RErr = CDR_readTrack(cdr.Prev);
 }
 
-

-void CDXA_Attenuation( s16 *buf, int size, int stereo )

-{

-	s16 *spsound;

-	s32 lc,rc;

-	int i;

-

-	spsound = buf;

-

-#if 0

-	// mono xa attenuation

-	// - Tales of Phantasia (voice meter)

-	if( stereo == 0 ) {

-		s16 temp[32768];

-		int dst;

-

-		dst = 0;

-		for( i = 0; i < size; i++, dst+=2 ) {

-			temp[dst+0] = spsound[i];

-			temp[dst+1] = spsound[i];

-		}

-

-		size *= 2*2;

-		memcpy( spsound, temp, size );

-	}

-#endif

-

-	for( i = 0; i < size / 2; i += 2 )

-	{

-		lc = (spsound[i+0] * cdr.AttenuatorLeft[0]  + spsound[i+1] * cdr.AttenuatorRight[1]) / 128;

-		rc = (spsound[i+1] * cdr.AttenuatorRight[0] + spsound[i+0] * cdr.AttenuatorLeft[1]) / 128;

-

-		if( lc < -32768 ) lc = -32768;

-		if( rc < -32768 ) rc = -32768;

-		if( lc > 32767 ) lc = 32767;

-		if( rc > 32767 ) rc = 32767;

-

-		spsound[i + 0] = lc;

-		spsound[i + 1] = rc;

-	}

-}

-

-

-void AddIrqQueue(unsigned char irq, unsigned long ecycle) {
+
+static void CDXA_Attenuation( s16 *buf, int size, int stereo )
+{
+	s16 *spsound;
+	s32 lc,rc;
+	int i;
+
+	spsound = buf;
+
+#if 0
+	// mono xa attenuation
+	// - Tales of Phantasia (voice meter)
+	if( stereo == 0 ) {
+		s16 temp[32768];
+		int dst;
+
+		dst = 0;
+		for( i = 0; i < size; i++, dst+=2 ) {
+			temp[dst+0] = spsound[i];
+			temp[dst+1] = spsound[i];
+		}
+
+		size *= 2*2;
+		memcpy( spsound, temp, size );
+	}
+#endif
+
+	for( i = 0; i < size / 2; i += 2 )
+	{
+		lc = (spsound[i+0] * cdr.AttenuatorLeft[0]  + spsound[i+1] * cdr.AttenuatorRight[1]) / 128;
+		rc = (spsound[i+1] * cdr.AttenuatorRight[0] + spsound[i+0] * cdr.AttenuatorLeft[1]) / 128;
+
+		if( lc < -32768 ) lc = -32768;
+		if( rc < -32768 ) rc = -32768;
+		if( lc > 32767 ) lc = 32767;
+		if( rc > 32767 ) rc = 32767;
+
+		spsound[i + 0] = lc;
+		spsound[i + 1] = rc;
+	}
+}
+
+
+static void AddIrqQueue(unsigned char irq, unsigned long ecycle) {
 	cdr.Irq = irq;
 	cdr.eCycle = ecycle;
 
@@ -539,7 +532,7 @@ void AddIrqQueue(unsigned char irq, unsigned long ecycle) {
 }
 
 
-void Set_Track()
+static void Set_Track()
 {
 	if (CDR_getTN(cdr.ResultTN) != -1) {
 		int lcv;
@@ -571,374 +564,374 @@ void Set_Track()
 }
 
 
-static u8 fake_subq_local[3], fake_subq_real[3], fake_subq_index, fake_subq_change;

-void Create_Fake_Subq()

-{

-	u8 temp_cur[3], temp_next[3], temp_start[3], pregap;

-	int diff;

-

-	if (CDR_getTN(cdr.ResultTN) == -1) return;

-	if( cdr.CurTrack+1 <= cdr.ResultTN[1] ) {

-		pregap = 150;

-		if( CDR_getTD(cdr.CurTrack+1, cdr.ResultTD) == -1 ) return;

-	} else {

-		// last track - cd size

-		pregap = 0;

-		if( CDR_getTD(0, cdr.ResultTD) == -1 ) return;

-	}

-

-	if( cdr.Play == TRUE ) {

-		temp_cur[0] = cdr.SetSectorPlay[0];

-		temp_cur[1] = cdr.SetSectorPlay[1];

-		temp_cur[2] = cdr.SetSectorPlay[2];

-	} else {

-		temp_cur[0] = btoi( cdr.Prev[0] );

-		temp_cur[1] = btoi( cdr.Prev[1] );

-		temp_cur[2] = btoi( cdr.Prev[2] );

-	}

-

-	fake_subq_real[0] = temp_cur[0];

-	fake_subq_real[1] = temp_cur[1];

-	fake_subq_real[2] = temp_cur[2];

-

-	temp_next[0] = cdr.ResultTD[2];

-	temp_next[1] = cdr.ResultTD[1];

-	temp_next[2] = cdr.ResultTD[0];

-

-

-	// flag- next track

-	if( msf2sec(temp_cur) >= msf2sec( temp_next )-pregap ) {

-		fake_subq_change = 1;

-

-		cdr.CurTrack++;

-

-		// end cd

-		if( pregap == 0 ) StopCdda();

-	}

-

-	//////////////////////////////////////////////////

-	//////////////////////////////////////////////////

-

-	// repair

-	if( cdr.CurTrack <= cdr.ResultTN[1] ) {

-		if( CDR_getTD(cdr.CurTrack, cdr.ResultTD) == -1 ) return;

-	} else {

-		// last track - cd size

-		if( CDR_getTD(0, cdr.ResultTD) == -1 ) return;

-	}

-	

-	temp_start[0] = cdr.ResultTD[2];

-	temp_start[1] = cdr.ResultTD[1];

-	temp_start[2] = cdr.ResultTD[0];

-

-

-#ifdef CDR_LOG

-	CDR_LOG( "CDDA FAKE SUB - %d:%d:%d / %d:%d:%d / %d:%d:%d\n",

-		temp_cur[0], temp_cur[1], temp_cur[2],

-		temp_start[0], temp_start[1], temp_start[2],

-		temp_next[0], temp_next[1], temp_next[2]);

-#endif

-

-

-

-	// local time - pregap / real

-	diff = msf2sec(temp_cur) - msf2sec( temp_start );

-	if( diff < 0 ) {

-		fake_subq_index = 0;

-

-		sec2msf( -diff, fake_subq_local );

-	} else {

-		fake_subq_index = 1;

-

-		sec2msf( diff, fake_subq_local );

-	}

-}

-

-

-void cdrPlayInterrupt_Autopause()

-{

-	if ((cdr.Mode & (MODE_AUTOPAUSE|MODE_CDDA)) != (MODE_AUTOPAUSE|MODE_CDDA)) return;

-

-	// Reschedule IRQ

-	if ( cdr.Irq || cdr.Stat ) {

-#ifdef CDR_LOG

-	CDR_LOG("=== BUSY === cdrPlayInterrupt\n");

-#endif

-

-		//CDRPLAY_INT( 0x800 );

-		return;

-	}

-	

-

-	if( CDR_getStatus(&stat) == -1) return;

-

-	subq = (struct SubQ *)CDR_getBufferSub();

-

-	if (subq != NULL ) {

-#ifdef CDR_LOG

-		CDR_LOG( "CDDA SUB - %X:%X:%X\n", 

-			subq->AbsoluteAddress[0], subq->AbsoluteAddress[1], subq->AbsoluteAddress[2] );

-#endif

-

-		/*

-		CDDA Autopause

-

-		Silhouette Mirage ($3)

-		Tomb Raider 1 ($7)

-		*/

-

-		if( cdr.CurTrack < btoi( subq->TrackNumber ) ) {

-#ifdef CDR_LOG

-			CDR_LOG( "CDDA STOP\n" );

-#endif

-

-			// Magic the Gathering

-			// - looping territory cdda

-

-			// ...?

-			//cdr.ResultReady = 1;

-			//cdr.Stat = DataReady;

-			cdr.Stat = DataEnd;

-			psxHu32ref(0x1070) |= SWAP32((u32)0x4);

-

-

-			StopCdda();

-		}

-	} else {

-#ifdef CDR_LOG___0

-		CDR_LOG( "CDDA FAKE SUB - %d:%d:%d\n", 

-			temp_cur[0], temp_cur[1], temp_cur[2] );

-#endif

-									

-		//if( msf2sec(temp_cur) >= msf2sec( temp_next ) ) {

-		if( fake_subq_change ) {

-#ifdef CDR_LOG

-			CDR_LOG( "CDDA STOP\n" );

-#endif

-			

-			// Magic the Gathering

-			// - looping territory cdda

-

-			// ...?

-			//cdr.ResultReady = 1;

-			//cdr.Stat = DataReady;

-			cdr.Stat = DataEnd;

-			psxHu32ref(0x1070) |= SWAP32((u32)0x4);

-

-

-			StopCdda();

-									

-			fake_subq_change = 0;

-		}

-	}

-}

-

-

-void cdrPlayInterrupt_Repplay()

-{

-	// BIOS - HACK: Switch between local / absolute times

-	static u8 report_time = 1;

-

-

-	if ((cdr.Mode & (MODE_REPORT|MODE_CDDA)) != (MODE_REPORT|MODE_CDDA)) return;

-

-#ifdef CDR_LOG

-	CDR_LOG("cdrRepplayInterrupt() Log: KEY END\n");

-#endif

-

-	// Doom - no more cdda playing

-	// - fixes boot with irq cmd reschedule

-

-	// Reschedule IRQ

-	if ( cdr.Irq || cdr.Stat ) {

-#ifdef CDR_LOG

-		CDR_LOG("=== BUSY === cdrRepplayInterrupt\n");

-#endif

-

-		//CDREPPLAY_INT( 0x800 );

-		return;

-	}

-	

-	

-	memset( cdr.Result, 0, 8 );

-	if( CDR_getStatus(&stat) == -1) return;

-

-	cdr.Result[0] = cdr.StatP;

-

-

-	subq = (struct SubQ *)CDR_getBufferSub();

-	if (subq != NULL ) {

-#ifdef CDR_LOG

-		CDR_LOG( "REPPLAY SUB - %X:%X:%X\n", 

-			subq->AbsoluteAddress[0], subq->AbsoluteAddress[1], subq->AbsoluteAddress[2] );

-#endif

-

-

-		/*

-		skip subQ integrity check (audio playback)

-		- mainly useful for DATA LibCrypt checking

-		*/

-		//if( SWAP16(subq->CRC) != calcCrc((unsigned char *)subq + 12, 10) )

-

-		// Rayman: audio pregap flag / track change

-		// - not all CDs will use PREGAPs, so we track it manually

-		if( cdr.CurTrack < btoi( subq->TrackNumber ) ) {

-			cdr.Result[0] |= 0x10;

-

-			cdr.CurTrack = btoi( subq->TrackNumber );

-		}

-

-

-		// BIOS CD Player: data already BCD format

-		cdr.Result[1] = subq->TrackNumber;

-		cdr.Result[2] = subq->IndexNumber;

-

-

-		// BIOS CD Player: switch between local / absolute times

-		if( report_time == 0 ) {

-			cdr.Result[3] = subq->AbsoluteAddress[0];

-			cdr.Result[4] = subq->AbsoluteAddress[1];

-			cdr.Result[5] = subq->AbsoluteAddress[2];

-

-			report_time = 1;

-		}	else {

-			cdr.Result[3] = subq->TrackRelativeAddress[0];

-			cdr.Result[4] = subq->TrackRelativeAddress[1];

-			cdr.Result[5] = subq->TrackRelativeAddress[2];

-

-			cdr.Result[4] |= 0x80;

-

-			report_time = 0;

-		}

-	} else {

-#ifdef CDR_LOG___0

-		CDR_LOG( "REPPLAY FAKE - %d:%d:%d\n", 

-			temp_cur[0], temp_cur[1], temp_cur[2] );

-#endif

-

-		// Rayman: check track change

-		//if( msf2sec(temp_cur) >= msf2sec( temp_next ) ) {

-		if( fake_subq_change ) {

-#ifdef CDR_LOG___0

-			CDR_LOG( "TRACK CHANGE %d - %d %d %d ==> %d %d %d\n",

-				cdr.CurTrack,

-				temp_cur[0], temp_cur[1], temp_cur[2],

-				temp_next[0], temp_next[1], temp_next[2] );

-#endif

-

-			cdr.Result[0] |= 0x10;

-									

-			fake_subq_change = 0;

-		}

-

-

-		// track # / index #

-		cdr.Result[1] = itob(cdr.CurTrack);

-		cdr.Result[2] = itob(fake_subq_index);

-

-		if( report_time == 0 ) {

-			// absolute

-			cdr.Result[3] = itob( fake_subq_real[0] );

-			cdr.Result[4] = itob( fake_subq_real[1] );

-			cdr.Result[5] = itob( fake_subq_real[2] );

-

-			report_time = 1;

-		} else {

-			// local

-			cdr.Result[3] = itob( fake_subq_local[0] );

-			cdr.Result[4] = itob( fake_subq_local[1] );

-			cdr.Result[5] = itob( fake_subq_local[2] );

-

-			cdr.Result[4] |= 0x80;

-

-			report_time = 0;

-		}

-

-		cdr.Result[6] = 0;

-		cdr.Result[7] = 0;

-	}

-

-

-	// Rayman: Logo freeze (resultready + dataready)

-	cdr.ResultReady = 1;

-	cdr.Stat = DataReady;

-

-	SetResultSize(8);

-	psxHu32ref(0x1070) |= SWAP32((u32)0x4);

-}

-

-	

-void cdrPlayInterrupt()

-{

-	if( !cdr.Play ) return;

-

-	//////////////////////////////////////////

-	//////////////////////////////////////////

-

-#ifdef CDR_LOG

-	CDR_LOG( "CDDA - %d:%d:%d\n", 

-		cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );

-#endif

-

-

-	{

-		u8 temp[3];

-

-		temp[0] = itob(cdr.SetSectorPlay[0]);

-		temp[1] = itob(cdr.SetSectorPlay[1]);

-		temp[2] = itob(cdr.SetSectorPlay[2]);

-

-		// get subq

-		CDR_readTrack( temp );

-	}

-

-	if( CDR_readCDDA ) {

-		CDR_readCDDA( cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], cdr.Transfer );

-		

-		CDXA_Attenuation( (short *) cdr.Transfer, 2352, 1 );

-	}

-

-

-

-	// mute data track

-	if( (Config.Cdda) ||

-			(CDR_getStatus(&stat) != -1 && stat.Type == 1 && cdr.CurTrack == 1) ) 

-		memset( cdr.Transfer, 0, CD_FRAMESIZE_RAW );

-

-

-	if( SPU_playCDDAchannel)

-		SPU_playCDDAchannel((short *)cdr.Transfer, CD_FRAMESIZE_RAW);

-

-	CDRPLAY_INT( cdReadTime );

-

-	//////////////////////////////////////////

-	//////////////////////////////////////////

-

-	subq = (struct SubQ *)CDR_getBufferSub();

-	if (subq == NULL )

-		Create_Fake_Subq();

-

-	cdrPlayInterrupt_Autopause();

-	cdrPlayInterrupt_Repplay();

-

-	//////////////////////////////////////////

-	//////////////////////////////////////////

-

-	cdr.SetSectorPlay[2]++;

-	if (cdr.SetSectorPlay[2] == 75) {

-		cdr.SetSectorPlay[2] = 0;

-		cdr.SetSectorPlay[1]++;

-		if (cdr.SetSectorPlay[1] == 60) {

-			cdr.SetSectorPlay[1] = 0;

-			cdr.SetSectorPlay[0]++;

-		}

-	}

-

-

-	Check_Shell(0);

-}

-

-

+static u8 fake_subq_local[3], fake_subq_real[3], fake_subq_index, fake_subq_change;
+static void Create_Fake_Subq()
+{
+	u8 temp_cur[3], temp_next[3], temp_start[3], pregap;
+	int diff;
+
+	if (CDR_getTN(cdr.ResultTN) == -1) return;
+	if( cdr.CurTrack+1 <= cdr.ResultTN[1] ) {
+		pregap = 150;
+		if( CDR_getTD(cdr.CurTrack+1, cdr.ResultTD) == -1 ) return;
+	} else {
+		// last track - cd size
+		pregap = 0;
+		if( CDR_getTD(0, cdr.ResultTD) == -1 ) return;
+	}
+
+	if( cdr.Play == TRUE ) {
+		temp_cur[0] = cdr.SetSectorPlay[0];
+		temp_cur[1] = cdr.SetSectorPlay[1];
+		temp_cur[2] = cdr.SetSectorPlay[2];
+	} else {
+		temp_cur[0] = btoi( cdr.Prev[0] );
+		temp_cur[1] = btoi( cdr.Prev[1] );
+		temp_cur[2] = btoi( cdr.Prev[2] );
+	}
+
+	fake_subq_real[0] = temp_cur[0];
+	fake_subq_real[1] = temp_cur[1];
+	fake_subq_real[2] = temp_cur[2];
+
+	temp_next[0] = cdr.ResultTD[2];
+	temp_next[1] = cdr.ResultTD[1];
+	temp_next[2] = cdr.ResultTD[0];
+
+
+	// flag- next track
+	if( msf2sec(temp_cur) >= msf2sec( temp_next )-pregap ) {
+		fake_subq_change = 1;
+
+		cdr.CurTrack++;
+
+		// end cd
+		if( pregap == 0 ) StopCdda();
+	}
+
+	//////////////////////////////////////////////////
+	//////////////////////////////////////////////////
+
+	// repair
+	if( cdr.CurTrack <= cdr.ResultTN[1] ) {
+		if( CDR_getTD(cdr.CurTrack, cdr.ResultTD) == -1 ) return;
+	} else {
+		// last track - cd size
+		if( CDR_getTD(0, cdr.ResultTD) == -1 ) return;
+	}
+	
+	temp_start[0] = cdr.ResultTD[2];
+	temp_start[1] = cdr.ResultTD[1];
+	temp_start[2] = cdr.ResultTD[0];
+
+
+#ifdef CDR_LOG
+	CDR_LOG( "CDDA FAKE SUB - %d:%d:%d / %d:%d:%d / %d:%d:%d\n",
+		temp_cur[0], temp_cur[1], temp_cur[2],
+		temp_start[0], temp_start[1], temp_start[2],
+		temp_next[0], temp_next[1], temp_next[2]);
+#endif
+
+
+
+	// local time - pregap / real
+	diff = msf2sec(temp_cur) - msf2sec( temp_start );
+	if( diff < 0 ) {
+		fake_subq_index = 0;
+
+		sec2msf( -diff, fake_subq_local );
+	} else {
+		fake_subq_index = 1;
+
+		sec2msf( diff, fake_subq_local );
+	}
+}
+
+
+static void cdrPlayInterrupt_Autopause()
+{
+	if ((cdr.Mode & (MODE_AUTOPAUSE|MODE_CDDA)) != (MODE_AUTOPAUSE|MODE_CDDA)) return;
+
+	// Reschedule IRQ
+	if ( cdr.Irq || cdr.Stat ) {
+#ifdef CDR_LOG
+	CDR_LOG("=== BUSY === cdrPlayInterrupt\n");
+#endif
+
+		//CDRPLAY_INT( 0x800 );
+		return;
+	}
+	
+
+	if( CDR_getStatus(&stat) == -1) return;
+
+	subq = (struct SubQ *)CDR_getBufferSub();
+
+	if (subq != NULL ) {
+#ifdef CDR_LOG
+		CDR_LOG( "CDDA SUB - %X:%X:%X\n", 
+			subq->AbsoluteAddress[0], subq->AbsoluteAddress[1], subq->AbsoluteAddress[2] );
+#endif
+
+		/*
+		CDDA Autopause
+
+		Silhouette Mirage ($3)
+		Tomb Raider 1 ($7)
+		*/
+
+		if( cdr.CurTrack < btoi( subq->TrackNumber ) ) {
+#ifdef CDR_LOG
+			CDR_LOG( "CDDA STOP\n" );
+#endif
+
+			// Magic the Gathering
+			// - looping territory cdda
+
+			// ...?
+			//cdr.ResultReady = 1;
+			//cdr.Stat = DataReady;
+			cdr.Stat = DataEnd;
+			psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+
+
+			StopCdda();
+		}
+	} else {
+#ifdef CDR_LOG___0
+		CDR_LOG( "CDDA FAKE SUB - %d:%d:%d\n", 
+			temp_cur[0], temp_cur[1], temp_cur[2] );
+#endif
+									
+		//if( msf2sec(temp_cur) >= msf2sec( temp_next ) ) {
+		if( fake_subq_change ) {
+#ifdef CDR_LOG
+			CDR_LOG( "CDDA STOP\n" );
+#endif
+			
+			// Magic the Gathering
+			// - looping territory cdda
+
+			// ...?
+			//cdr.ResultReady = 1;
+			//cdr.Stat = DataReady;
+			cdr.Stat = DataEnd;
+			psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+
+
+			StopCdda();
+									
+			fake_subq_change = 0;
+		}
+	}
+}
+
+
+static void cdrPlayInterrupt_Repplay()
+{
+	// BIOS - HACK: Switch between local / absolute times
+	static u8 report_time = 1;
+
+
+	if ((cdr.Mode & (MODE_REPORT|MODE_CDDA)) != (MODE_REPORT|MODE_CDDA)) return;
+
+#ifdef CDR_LOG
+	CDR_LOG("cdrRepplayInterrupt() Log: KEY END\n");
+#endif
+
+	// Doom - no more cdda playing
+	// - fixes boot with irq cmd reschedule
+
+	// Reschedule IRQ
+	if ( cdr.Irq || cdr.Stat ) {
+#ifdef CDR_LOG
+		CDR_LOG("=== BUSY === cdrRepplayInterrupt\n");
+#endif
+
+		//CDREPPLAY_INT( 0x800 );
+		return;
+	}
+	
+	
+	memset( cdr.Result, 0, 8 );
+	if( CDR_getStatus(&stat) == -1) return;
+
+	cdr.Result[0] = cdr.StatP;
+
+
+	subq = (struct SubQ *)CDR_getBufferSub();
+	if (subq != NULL ) {
+#ifdef CDR_LOG
+		CDR_LOG( "REPPLAY SUB - %X:%X:%X\n", 
+			subq->AbsoluteAddress[0], subq->AbsoluteAddress[1], subq->AbsoluteAddress[2] );
+#endif
+
+
+		/*
+		skip subQ integrity check (audio playback)
+		- mainly useful for DATA LibCrypt checking
+		*/
+		//if( SWAP16(subq->CRC) != calcCrc((unsigned char *)subq + 12, 10) )
+
+		// Rayman: audio pregap flag / track change
+		// - not all CDs will use PREGAPs, so we track it manually
+		if( cdr.CurTrack < btoi( subq->TrackNumber ) ) {
+			cdr.Result[0] |= 0x10;
+
+			cdr.CurTrack = btoi( subq->TrackNumber );
+		}
+
+
+		// BIOS CD Player: data already BCD format
+		cdr.Result[1] = subq->TrackNumber;
+		cdr.Result[2] = subq->IndexNumber;
+
+
+		// BIOS CD Player: switch between local / absolute times
+		if( report_time == 0 ) {
+			cdr.Result[3] = subq->AbsoluteAddress[0];
+			cdr.Result[4] = subq->AbsoluteAddress[1];
+			cdr.Result[5] = subq->AbsoluteAddress[2];
+
+			report_time = 1;
+		}	else {
+			cdr.Result[3] = subq->TrackRelativeAddress[0];
+			cdr.Result[4] = subq->TrackRelativeAddress[1];
+			cdr.Result[5] = subq->TrackRelativeAddress[2];
+
+			cdr.Result[4] |= 0x80;
+
+			report_time = 0;
+		}
+	} else {
+#ifdef CDR_LOG___0
+		CDR_LOG( "REPPLAY FAKE - %d:%d:%d\n", 
+			temp_cur[0], temp_cur[1], temp_cur[2] );
+#endif
+
+		// Rayman: check track change
+		//if( msf2sec(temp_cur) >= msf2sec( temp_next ) ) {
+		if( fake_subq_change ) {
+#ifdef CDR_LOG___0
+			CDR_LOG( "TRACK CHANGE %d - %d %d %d ==> %d %d %d\n",
+				cdr.CurTrack,
+				temp_cur[0], temp_cur[1], temp_cur[2],
+				temp_next[0], temp_next[1], temp_next[2] );
+#endif
+
+			cdr.Result[0] |= 0x10;
+									
+			fake_subq_change = 0;
+		}
+
+
+		// track # / index #
+		cdr.Result[1] = itob(cdr.CurTrack);
+		cdr.Result[2] = itob(fake_subq_index);
+
+		if( report_time == 0 ) {
+			// absolute
+			cdr.Result[3] = itob( fake_subq_real[0] );
+			cdr.Result[4] = itob( fake_subq_real[1] );
+			cdr.Result[5] = itob( fake_subq_real[2] );
+
+			report_time = 1;
+		} else {
+			// local
+			cdr.Result[3] = itob( fake_subq_local[0] );
+			cdr.Result[4] = itob( fake_subq_local[1] );
+			cdr.Result[5] = itob( fake_subq_local[2] );
+
+			cdr.Result[4] |= 0x80;
+
+			report_time = 0;
+		}
+
+		cdr.Result[6] = 0;
+		cdr.Result[7] = 0;
+	}
+
+
+	// Rayman: Logo freeze (resultready + dataready)
+	cdr.ResultReady = 1;
+	cdr.Stat = DataReady;
+
+	SetResultSize(8);
+	psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+}
+
+	
+void cdrPlayInterrupt()
+{
+	if( !cdr.Play ) return;
+
+	//////////////////////////////////////////
+	//////////////////////////////////////////
+
+#ifdef CDR_LOG
+	CDR_LOG( "CDDA - %d:%d:%d\n", 
+		cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
+#endif
+
+
+	{
+		u8 temp[3];
+
+		temp[0] = itob(cdr.SetSectorPlay[0]);
+		temp[1] = itob(cdr.SetSectorPlay[1]);
+		temp[2] = itob(cdr.SetSectorPlay[2]);
+
+		// get subq
+		CDR_readTrack( temp );
+	}
+
+	if( CDR_readCDDA ) {
+		CDR_readCDDA( cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], cdr.Transfer );
+		
+		CDXA_Attenuation( (short *) cdr.Transfer, 2352, 1 );
+	}
+
+
+
+	// mute data track
+	if( (Config.Cdda) ||
+			(CDR_getStatus(&stat) != -1 && stat.Type == 1 && cdr.CurTrack == 1) ) 
+		memset( cdr.Transfer, 0, CD_FRAMESIZE_RAW );
+
+
+	if( SPU_playCDDAchannel)
+		SPU_playCDDAchannel((short *)cdr.Transfer, CD_FRAMESIZE_RAW);
+
+	CDRPLAY_INT( cdReadTime );
+
+	//////////////////////////////////////////
+	//////////////////////////////////////////
+
+	subq = (struct SubQ *)CDR_getBufferSub();
+	if (subq == NULL )
+		Create_Fake_Subq();
+
+	cdrPlayInterrupt_Autopause();
+	cdrPlayInterrupt_Repplay();
+
+	//////////////////////////////////////////
+	//////////////////////////////////////////
+
+	cdr.SetSectorPlay[2]++;
+	if (cdr.SetSectorPlay[2] == 75) {
+		cdr.SetSectorPlay[2] = 0;
+		cdr.SetSectorPlay[1]++;
+		if (cdr.SetSectorPlay[1] == 60) {
+			cdr.SetSectorPlay[1] = 0;
+			cdr.SetSectorPlay[0]++;
+		}
+	}
+
+
+	Check_Shell(0);
+}
+
+
 void cdrInterrupt() {
 	int i;
 	unsigned char Irq = cdr.Irq;
@@ -977,13 +970,13 @@ void cdrInterrupt() {
 			break;
 
 		case CdlPlay:
-			fake_subq_change = 0;

-

-			if( cdr.Seeked == FALSE ) {

-				memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 );

-				cdr.Seeked = TRUE;

-			}

-

+			fake_subq_change = 0;
+
+			if( cdr.Seeked == FALSE ) {
+				memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 );
+				cdr.Seeked = TRUE;
+			}
+
 			/*
 			Rayman: detect track changes
 			- fixes logo freeze
@@ -1060,11 +1053,11 @@ void cdrInterrupt() {
 								cdr.SetSectorPlay[1] = cdr.ResultTD[1];
 								cdr.SetSectorPlay[2] = cdr.ResultTD[0];
 
-								// reset data

-								Set_Track();

-								Find_CurTrack();

-								ReadTrack( cdr.SetSectorPlay );

-

+								// reset data
+								Set_Track();
+								Find_CurTrack();
+								ReadTrack( cdr.SetSectorPlay );
+
 								//CDR_play(cdr.SetSectorPlay);
 							}
 						}
@@ -1084,12 +1077,12 @@ void cdrInterrupt() {
 			cdr.Stat = Acknowledge;
 
 			cdr.StatP |= STATUS_PLAY;
-

-			

-			// BIOS player - set flag again

-			cdr.Play = TRUE;

 
-			CDRPLAY_INT( cdReadTime );

+			
+			// BIOS player - set flag again
+			cdr.Play = TRUE;
+
+			CDRPLAY_INT( cdReadTime );
 			break;
 
     	case CdlForward:
@@ -1251,30 +1244,30 @@ void cdrInterrupt() {
 						memset(cdr.Result + 2, 0, 3 + 3); // CRC wrong, wipe out time data
 					}
 				}
-			} else {

-				if( cdr.Play == FALSE ) Create_Fake_Subq();

-

-

-				// track # / index #

-				cdr.Result[0] = itob(cdr.CurTrack);

-				cdr.Result[1] = itob(fake_subq_index);

-

-				// local

-				cdr.Result[2] = itob( fake_subq_local[0] );

-				cdr.Result[3] = itob( fake_subq_local[1] );

-				cdr.Result[4] = itob( fake_subq_local[2] );

-

-				// absolute

-				cdr.Result[5] = itob( fake_subq_real[0] );

-				cdr.Result[6] = itob( fake_subq_real[1] );

-				cdr.Result[7] = itob( fake_subq_real[2] );

-			}

-
-			// redump.org - wipe time

-			if( !cdr.Play && CheckSBI(cdr.Result+5) ) {

-				memset( cdr.Result+2, 0, 6 );

-			}

-

+			} else {
+				if( cdr.Play == FALSE ) Create_Fake_Subq();
+
+
+				// track # / index #
+				cdr.Result[0] = itob(cdr.CurTrack);
+				cdr.Result[1] = itob(fake_subq_index);
+
+				// local
+				cdr.Result[2] = itob( fake_subq_local[0] );
+				cdr.Result[3] = itob( fake_subq_local[1] );
+				cdr.Result[4] = itob( fake_subq_local[2] );
+
+				// absolute
+				cdr.Result[5] = itob( fake_subq_real[0] );
+				cdr.Result[6] = itob( fake_subq_real[1] );
+				cdr.Result[7] = itob( fake_subq_real[2] );
+			}
+
+			// redump.org - wipe time
+			if( !cdr.Play && CheckSBI(cdr.Result+5) ) {
+				memset( cdr.Result+2, 0, 6 );
+			}
+
 			cdr.Stat = Acknowledge;
 			break;
 
@@ -1320,21 +1313,21 @@ void cdrInterrupt() {
 			cdr.StatP |= STATUS_ROTATING;
         	cdr.Result[0] = cdr.StatP;
 			cdr.StatP |= STATUS_SEEK;
-        	cdr.Stat = Acknowledge;

-

-			/*

-			Crusaders of Might and Magic = 0.5x-4x

-			- fix cutscene speech start

-

-			Eggs of Steel = 2x-?

-			- fix new game

-

-			Medievil = ?-4x

-			- fix cutscene speech

-

-			Rockman X5 = 0.5-4x

-			- fix capcom logo

-			*/

+        	cdr.Stat = Acknowledge;
+
+			/*
+			Crusaders of Might and Magic = 0.5x-4x
+			- fix cutscene speech start
+
+			Eggs of Steel = 2x-?
+			- fix new game
+
+			Medievil = ?-4x
+			- fix cutscene speech
+
+			Rockman X5 = 0.5-4x
+			- fix capcom logo
+			*/
 			AddIrqQueue(CdlSeekL + 0x20, cdReadTime * 4);
 			break;
 
@@ -1345,10 +1338,10 @@ void cdrInterrupt() {
         	cdr.Result[0] = cdr.StatP;
 			cdr.Seeked = TRUE;
         	cdr.Stat = Complete;
-

-			

-			// Mega Man Legends 2: must update read cursor for getlocp

-			ReadTrack( cdr.SetSector );

+
+			
+			// Mega Man Legends 2: must update read cursor for getlocp
+			ReadTrack( cdr.SetSector );
 			break;
 
     	case CdlSeekP:
@@ -1357,7 +1350,7 @@ void cdrInterrupt() {
         	cdr.Result[0] = cdr.StatP;
 			cdr.StatP |= STATUS_SEEK;
         	cdr.Stat = Acknowledge;
-			AddIrqQueue(CdlSeekP + 0x20, cdReadTime * 1);

+			AddIrqQueue(CdlSeekP + 0x20, cdReadTime * 1);
 			break;
 
     	case CdlSeekP + 0x20:
@@ -1368,12 +1361,12 @@ void cdrInterrupt() {
 			cdr.Stat = Complete;
 			cdr.Seeked = TRUE;
 
-			// GameShark Music Player

-			memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 );

-

-			// Tomb Raider 2: must update read cursor for getlocp

-			Find_CurTrack();

-			ReadTrack( cdr.SetSectorPlay );

+			// GameShark Music Player
+			memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 );
+
+			// Tomb Raider 2: must update read cursor for getlocp
+			Find_CurTrack();
+			ReadTrack( cdr.SetSectorPlay );
 			break;
 
 		case CdlTest:
@@ -1489,43 +1482,43 @@ void cdrInterrupt() {
 		case READ_ACK:
 			if (!cdr.Reading) return;
 
-			

-			// Fighting Force 2 - update subq time immediately

-			// - fixes new game

-			ReadTrack( cdr.SetSector );

-

-

-			// Crusaders of Might and Magic - update getlocl now

-			// - fixes cutscene speech

-			{

-				u8 *buf = CDR_getBuffer();

-				memcpy(cdr.Transfer, buf, 8);

-			}

-			

-			

-			/*

-			Duke Nukem: Land of the Babes - seek then delay read for one frame

-			- fixes cutscenes

-			*/

-

+			
+			// Fighting Force 2 - update subq time immediately
+			// - fixes new game
+			ReadTrack( cdr.SetSector );
+
+
+			// Crusaders of Might and Magic - update getlocl now
+			// - fixes cutscene speech
+			{
+				u8 *buf = CDR_getBuffer();
+				memcpy(cdr.Transfer, buf, 8);
+			}
+			
+			
+			/*
+			Duke Nukem: Land of the Babes - seek then delay read for one frame
+			- fixes cutscenes
+			*/
+
 			if (!cdr.Seeked) {
 				cdr.Seeked = TRUE;
 
 				cdr.StatP |= STATUS_SEEK;
-				cdr.StatP &= ~STATUS_READ;

-

-				// Crusaders of Might and Magic - use short time

-				// - fix cutscene speech (startup)

-

-				// ??? - use more accurate seek time later

-				CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);

-			} else {

-				cdr.StatP |= STATUS_READ;

-				cdr.StatP &= ~STATUS_SEEK;

-

-				CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);

-			}

-

+				cdr.StatP &= ~STATUS_READ;
+
+				// Crusaders of Might and Magic - use short time
+				// - fix cutscene speech (startup)
+
+				// ??? - use more accurate seek time later
+				CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
+			} else {
+				cdr.StatP |= STATUS_READ;
+				cdr.StatP &= ~STATUS_SEEK;
+
+				CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
+			}
+
 			SetResultSize(1);
 			cdr.StatP |= STATUS_ROTATING;
 			cdr.Result[0] = cdr.StatP;
@@ -1599,52 +1592,52 @@ void cdrReadInterrupt() {
 
 	if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
 		// Firemen 2: Multi-XA files - briefings, cutscenes
-		if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {

-			cdr.File = cdr.Transfer[4 + 0];

-			cdr.Channel = cdr.Transfer[4 + 1];

-		}

-

-		if((cdr.Transfer[4 + 2] & 0x4) &&

-			 (cdr.Transfer[4 + 1] == cdr.Channel) &&

-			 (cdr.Transfer[4 + 0] == cdr.File)) {

-			int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);

-
-			if (!ret) {

-				int xa_type;

-

-#if 0

-				// save - set only for FirstSector

-				xa_type = cdr.Xa.stereo;

-

-

-				// Duke Nukem - Time to Kill - speech, music volume control

-				// Tekken 3 - post-match fade out

-				if( cdr.Xa.stereo == 0 )

-					CDXA_Attenuation( cdr.Xa.pcm, cdr.Xa.nsamples * 2, cdr.Xa.stereo );

-				else

-					CDXA_Attenuation( cdr.Xa.pcm, cdr.Xa.nsamples * 4, cdr.Xa.stereo );

-

-

-				// fix mono xa attenuation

-				if( cdr.Xa.stereo == 0 ) cdr.Xa.stereo = 1;

-#endif

+		if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {
+			cdr.File = cdr.Transfer[4 + 0];
+			cdr.Channel = cdr.Transfer[4 + 1];
+		}
+
+		if((cdr.Transfer[4 + 2] & 0x4) &&
+			 (cdr.Transfer[4 + 1] == cdr.Channel) &&
+			 (cdr.Transfer[4 + 0] == cdr.File)) {
+			int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
+
+			if (!ret) {
+#if 0
+				int xa_type;
+
+				// save - set only for FirstSector
+				xa_type = cdr.Xa.stereo;
+
+
+				// Duke Nukem - Time to Kill - speech, music volume control
+				// Tekken 3 - post-match fade out
+				if( cdr.Xa.stereo == 0 )
+					CDXA_Attenuation( cdr.Xa.pcm, cdr.Xa.nsamples * 2, cdr.Xa.stereo );
+				else
+					CDXA_Attenuation( cdr.Xa.pcm, cdr.Xa.nsamples * 4, cdr.Xa.stereo );
+
+
+				// fix mono xa attenuation
+				if( cdr.Xa.stereo == 0 ) cdr.Xa.stereo = 1;
+#endif
 
 				SPU_playADPCMchannel(&cdr.Xa);
 				cdr.FirstSector = 0;
-

-

-#if 0

-				cdr.Xa.stereo = xa_type;

-#endif

 
-

+
+#if 0
+				cdr.Xa.stereo = xa_type;
+#endif
+
+
 #if 0
-				// Crash Team Racing: music, speech

-				// - done using cdda decoded buffer (spu irq)

+				// Crash Team Racing: music, speech
+				// - done using cdda decoded buffer (spu irq)
 				// - don't do here
 
 				// signal ADPCM data ready
-				psxHu32ref(0x1070) |= SWAP32((u32)0x200);

+				psxHu32ref(0x1070) |= SWAP32((u32)0x200);
 #endif
 			}
 			else cdr.FirstSector = -1;
@@ -1677,9 +1670,9 @@ void cdrReadInterrupt() {
 	}
 
 	/*
-	Croc 2: $40 - only FORM1 (*)

-	Judge Dredd: $C8 - only FORM1 (*)

-	Sim Theme Park - no adpcm at all (zero)

+	Croc 2: $40 - only FORM1 (*)
+	Judge Dredd: $C8 - only FORM1 (*)
+	Sim Theme Park - no adpcm at all (zero)
 	*/
 
 	if( (cdr.Mode & MODE_STRSND) == 0 || (cdr.Transfer[4+2] & 0x4) != 0x4 ) {
@@ -1689,7 +1682,7 @@ void cdrReadInterrupt() {
 		// Rockman X5 - no music restart problem
         cdr.Stat = NoIntr;
     }
-    psxHu32ref(0x1070) |= SWAP32((u32)0x4);

+    psxHu32ref(0x1070) |= SWAP32((u32)0x4);
 
 	Check_Shell(0);
 }
@@ -1746,13 +1739,13 @@ void cdrWrite0(unsigned char rt) {
 
 	// Tekken: CDXA fade-out
 	else if( rt == 2 ) {
-		//cdr.AttenuatorLeft[0] = 0;

-		//cdr.AttenuatorLeft[1] = 0;

+		//cdr.AttenuatorLeft[0] = 0;
+		//cdr.AttenuatorLeft[1] = 0;
 	}
 	else if( rt == 3 ) {
-		// Tekken 3 - character menu (don't do this!)

-		//cdr.AttenuatorRight[0] = 0;

-		//cdr.AttenuatorRight[1] = 0;

+		// Tekken 3 - character menu (don't do this!)
+		//cdr.AttenuatorRight[0] = 0;
+		//cdr.AttenuatorRight[1] = 0;
 	}
 }
 
@@ -1782,7 +1775,7 @@ void cdrWrite1(unsigned char rt) {
 
 	// Tekken: CDXA fade-out
 	if( (cdr.Ctrl & 3) == 3 ) {
-		cdr.AttenuatorRight[0] = rt;

+		cdr.AttenuatorRight[0] = rt;
 	}
 
 
@@ -1813,8 +1806,8 @@ void cdrWrite1(unsigned char rt) {
 
     	case CdlNop:
 			cdr.Ctrl |= 0x80;
-    		cdr.Stat = NoIntr;

-

+    		cdr.Stat = NoIntr;
+
 				// Twisted Metal 3 - fix music
     		AddIrqQueue(cdr.Cmd, 0x800);
         	break;
@@ -1934,7 +1927,7 @@ void cdrWrite1(unsigned char rt) {
 				/*
 				GameShark CD Player: save time for resume
 
-				Twisted Metal - World Tour: don't mix Setloc / CdlPlay cursors

+				Twisted Metal - World Tour: don't mix Setloc / CdlPlay cursors
 				*/
 
 				StopCdda();
@@ -1959,8 +1952,8 @@ void cdrWrite1(unsigned char rt) {
     		cdr.Stat = NoIntr;
     		AddIrqQueue(cdr.Cmd, 0x800);
 
-			// Duke Nukem - Time to Kill

-			// - do not directly set cd-xa volume

+			// Duke Nukem - Time to Kill
+			// - do not directly set cd-xa volume
 			//SPU_writeRegister( H_CDLeft, 0x0000 );
 			//SPU_writeRegister( H_CDRight, 0x0000 );
         	break;
@@ -1971,8 +1964,8 @@ void cdrWrite1(unsigned char rt) {
     		cdr.Stat = NoIntr;
     		AddIrqQueue(cdr.Cmd, 0x800);
 
-			// Duke Nukem - Time to Kill

-			// - do not directly set cd-xa volume

+			// Duke Nukem - Time to Kill
+			// - do not directly set cd-xa volume
 			//SPU_writeRegister( H_CDLeft, 0x7f00 );
 			//SPU_writeRegister( H_CDRight, 0x7f00 );
         	break;
@@ -2016,13 +2009,13 @@ void cdrWrite1(unsigned char rt) {
 
     	case CdlGetlocP:
 				cdr.Ctrl |= 0x80;
-	  		cdr.Stat = NoIntr;

+	  		cdr.Stat = NoIntr;
 				
 				// GameShark CDX / Lite Player: pretty narrow time window
 				// - doesn't always work due to time inprecision
-				//AddIrqQueue(cdr.Cmd, 0x28);

-

-				// Tomb Raider 2 - cdda

+				//AddIrqQueue(cdr.Cmd, 0x28);
+
+				// Tomb Raider 2 - cdda
 				AddIrqQueue(cdr.Cmd, 0x40);
        	break;
 
@@ -2046,21 +2039,21 @@ void cdrWrite1(unsigned char rt) {
 			cdr.Ctrl |= 0x80;
     		cdr.Stat = NoIntr;
     		AddIrqQueue(cdr.Cmd, 0x800);
-

-				StopCdda();

-				StopReading();

-

+
+				StopCdda();
+				StopReading();
+
         	break;
 
     	case CdlSeekP:
 //        	((u32 *)cdr.SetSectorSeek)[0] = ((u32 *)cdr.SetSector)[0];
 			cdr.Ctrl |= 0x80;
     		cdr.Stat = NoIntr;
-

-				// Tomb Raider 2 - reset cdda

-				StopCdda();

-				StopReading();

-

+
+				// Tomb Raider 2 - reset cdda
+				StopCdda();
+				StopReading();
+
     		AddIrqQueue(cdr.Cmd, 0x800);
         	break;
 
@@ -2131,10 +2124,10 @@ void cdrWrite2(unsigned char rt) {
 
 	// Tekken: CDXA fade-out
 	if( (cdr.Ctrl & 3) == 2 ) {
-		cdr.AttenuatorLeft[0] = rt;

+		cdr.AttenuatorLeft[0] = rt;
 	}
 	else if( (cdr.Ctrl & 3) == 3 ) {
-		cdr.AttenuatorRight[1] = rt;

+		cdr.AttenuatorRight[1] = rt;
 	}
 
 
@@ -2180,14 +2173,14 @@ void cdrWrite3(unsigned char rt) {
 
 	// Tekken: CDXA fade-out
 	if( (cdr.Ctrl & 3) == 2 ) {
-		cdr.AttenuatorLeft[1] = rt;

+		cdr.AttenuatorLeft[1] = rt;
 	}
 	else if( (cdr.Ctrl & 3) == 3 && rt == 0x20 ) {
-#ifdef CDR_LOG

-		CDR_LOG( "CD-XA Volume: %X %X | %X %X\n",

-			cdr.AttenuatorLeft[0], cdr.AttenuatorLeft[1],

-			cdr.AttenuatorRight[0], cdr.AttenuatorRight[1] );

-#endif

+#ifdef CDR_LOG
+		CDR_LOG( "CD-XA Volume: %X %X | %X %X\n",
+			cdr.AttenuatorLeft[0], cdr.AttenuatorLeft[1],
+			cdr.AttenuatorRight[0], cdr.AttenuatorRight[1] );
+#endif
 	}
 
 
@@ -2212,23 +2205,23 @@ void cdrWrite3(unsigned char rt) {
 			cdr.Irq = 0;
 			return;
 		}
-

+
 #if 1
-		if (cdr.Reading && !cdr.ResultReady) {

-      CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime);

-		}

-#else

-		// XA streaming - incorrect timing because of this reschedule

-		// - Final Fantasy Tactics

-		// - various other games

-

-		/*

-		if (cdr.Reading && !cdr.ResultReady) {

-      CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime);

-		}

-		*/

-#endif

-

+		if (cdr.Reading && !cdr.ResultReady) {
+      CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime);
+		}
+#else
+		// XA streaming - incorrect timing because of this reschedule
+		// - Final Fantasy Tactics
+		// - various other games
+
+		/*
+		if (cdr.Reading && !cdr.ResultReady) {
+      CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime);
+		}
+		*/
+#endif
+
 		return;
 	}
 
@@ -2236,9 +2229,9 @@ void cdrWrite3(unsigned char rt) {
 		cdr.Readed = 1;
 		cdr.pTransfer = cdr.Transfer;
 
-		switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {

-			case MODE_SIZE_2328:

-			case MODE_SIZE_2048:

+		switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
+			case MODE_SIZE_2328:
+			case MODE_SIZE_2048:
 				cdr.pTransfer += 12;
 				break;
 
@@ -2254,7 +2247,7 @@ void cdrWrite3(unsigned char rt) {
 
 void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 	u32 cdsize;
-	u8 *ptr, *cdwrap_ptr;

+	u8 *ptr;
 
 #ifdef CDR_LOG
 	CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
@@ -2272,18 +2265,18 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 
 			cdsize = (bcr & 0xffff) * 4;
 
-			// Ape Escape: bcr = 0001 / 0000

-			// - fix boot

-			if( cdsize == 0 )

-			{

-				switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {

-					case MODE_SIZE_2340: cdsize = 2340; break;

-					case MODE_SIZE_2328: cdsize = 2328; break;

-					case MODE_SIZE_2048: cdsize = 2048; break;

-				}

-			}

-

-

+			// Ape Escape: bcr = 0001 / 0000
+			// - fix boot
+			if( cdsize == 0 )
+			{
+				switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
+					case MODE_SIZE_2340: cdsize = 2340; break;
+					case MODE_SIZE_2328: cdsize = 2328; break;
+					case MODE_SIZE_2048: cdsize = 2048; break;
+				}
+			}
+
+
 			ptr = (u8 *)PSXM(madr);
 			if (ptr == NULL) {
 #ifdef CPU_LOG
@@ -2292,8 +2285,8 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 				break;
 			}
 
-

-#if 1

+
+#if 1
 			/*
 			GS CDX: Enhancement CD crash
 			- Setloc 0:0:0
@@ -2313,70 +2306,70 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 
 			psxCpu->Clear(madr, cdsize / 4);
 			cdr.pTransfer += cdsize;
-#else

-			cdwrap_ptr = cdr.Transfer;

-			switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {

-				case MODE_SIZE_2340: cdwrap_ptr += 2340; break;

-				case MODE_SIZE_2328: cdwrap_ptr += 12 + 2328; break;

-				case MODE_SIZE_2048: cdwrap_ptr += 12 + 2048; break;

-			}

-

-

-			// fast copy - no wrap

-			if( cdr.pTransfer + cdsize <= cdwrap_ptr ) {

-				memcpy(ptr, cdr.pTransfer, cdsize);

-

-				psxCpu->Clear(madr, cdsize / 4);

-				cdr.pTransfer += cdsize;

-			} else {

-				int lcv;

-

-				/*

-				CDROM wrapping

-

-				Ape Escape - used several times

-				Gameshark Lite - opening movie

-

-				Gameshark CDX: enhancement CD patcher

-				- calls CdlPlay @ 0:2:0

-				- spams DMA3 and overruns buffer

-				*/

-

-				for( lcv = 0; lcv < cdsize; lcv++ )

-				{

-					// wrap cdrom ptr

-					if( cdr.pTransfer == cdwrap_ptr ) {

-						switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {

-							case MODE_SIZE_2328:

-							case MODE_SIZE_2048:

-								cdr.pTransfer = cdr.Transfer + 12;

-								break;

-

-							case MODE_SIZE_2340:

-								cdr.pTransfer = cdr.Transfer + 0;

-								break;

-						}

-					}

-

-

-					*(ptr+lcv) = *cdr.pTransfer;

-	

-					cdr.pTransfer++;

-				}

-

-

-				psxCpu->Clear(madr, cdsize / 4);

-			}

-#endif

+#else
+			u8 *cdwrap_ptr = cdr.Transfer;
+			switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
+				case MODE_SIZE_2340: cdwrap_ptr += 2340; break;
+				case MODE_SIZE_2328: cdwrap_ptr += 12 + 2328; break;
+				case MODE_SIZE_2048: cdwrap_ptr += 12 + 2048; break;
+			}
+
+
+			// fast copy - no wrap
+			if( cdr.pTransfer + cdsize <= cdwrap_ptr ) {
+				memcpy(ptr, cdr.pTransfer, cdsize);
+
+				psxCpu->Clear(madr, cdsize / 4);
+				cdr.pTransfer += cdsize;
+			} else {
+				int lcv;
+
+				/*
+				CDROM wrapping
+
+				Ape Escape - used several times
+				Gameshark Lite - opening movie
+
+				Gameshark CDX: enhancement CD patcher
+				- calls CdlPlay @ 0:2:0
+				- spams DMA3 and overruns buffer
+				*/
+
+				for( lcv = 0; lcv < cdsize; lcv++ )
+				{
+					// wrap cdrom ptr
+					if( cdr.pTransfer == cdwrap_ptr ) {
+						switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
+							case MODE_SIZE_2328:
+							case MODE_SIZE_2048:
+								cdr.pTransfer = cdr.Transfer + 12;
+								break;
+
+							case MODE_SIZE_2340:
+								cdr.pTransfer = cdr.Transfer + 0;
+								break;
+						}
+					}
+
+
+					*(ptr+lcv) = *cdr.pTransfer;
+	
+					cdr.pTransfer++;
+				}
+
+
+				psxCpu->Clear(madr, cdsize / 4);
+			}
+#endif
 
 
 			// burst vs normal
-			if( chcr == 0x11400100 ) {

+			if( chcr == 0x11400100 ) {
 #if 1
-				CDRDMA_INT( (cdsize/4) / 4 );

-#else

-				// Experimental burst dma transfer (0.333x max)

-				CDRDMA_INT( (cdsize/4) / 3 );

+				CDRDMA_INT( (cdsize/4) / 4 );
+#else
+				// Experimental burst dma transfer (0.333x max)
+				CDRDMA_INT( (cdsize/4) / 3 );
 #endif
 			}
 			else if( chcr == 0x11000000 ) {
@@ -2405,30 +2398,30 @@ void cdrReset() {
 	memset(&cdr, 0, sizeof(cdr));
 	cdr.CurTrack = 1;
 	cdr.File = 1;
-	cdr.Channel = 1;

-

-#if 0

-	// BIOS player - default values

-	cdr.AttenuatorLeft[0] = 0x80;

-	cdr.AttenuatorLeft[1] = 0x00;

-	cdr.AttenuatorRight[0] = 0x80;

-	cdr.AttenuatorRight[1] = 0x00;

-#endif

+	cdr.Channel = 1;
+
+#if 0
+	// BIOS player - default values
+	cdr.AttenuatorLeft[0] = 0x80;
+	cdr.AttenuatorLeft[1] = 0x00;
+	cdr.AttenuatorRight[0] = 0x80;
+	cdr.AttenuatorRight[1] = 0x00;
+#endif
 }
 
 int cdrFreeze(gzFile f, int Mode) {
 	uintptr_t tmp;
-

-

-	if( Mode == 0 ) {

-		StopCdda();

-	}

-	

-	

+
+
+	if( Mode == 0 ) {
+		StopCdda();
+	}
+	
+	
 	gzfreeze(&cdr, sizeof(cdr));
-

 
-	

+
+	
 	if (Mode == 1)
 		tmp = cdr.pTransfer - cdr.Transfer;
 
@@ -2442,9 +2435,9 @@ int cdrFreeze(gzFile f, int Mode) {
 
 void LidInterrupt() {
 	cdr.LidCheck = 0x20; // start checker
-

-	CDRLID_INT( cdReadTime * 3 );

-	

+
+	CDRLID_INT( cdReadTime * 3 );
+	
 	// generate interrupt if none active - open or close
 	if (cdr.Irq == 0 || cdr.Irq == 0xff) {
 		cdr.Ctrl |= 0x80;
diff --git a/libpcsxcore/cdrom.h b/libpcsxcore/cdrom.h
index c943f3b1..355f1c6a 100644
--- a/libpcsxcore/cdrom.h
+++ b/libpcsxcore/cdrom.h
@@ -71,7 +71,7 @@ typedef struct {
 	unsigned char ResultTD[4];
 	unsigned char SetSector[4];
 	unsigned char SetSectorSeek[4];
-	unsigned char SetSectorPlay[4];

+	unsigned char SetSectorPlay[4];
 	unsigned char Track;
 	boolean Play, Muted;
 	int CurTrack;
@@ -90,21 +90,22 @@ typedef struct {
 	boolean Seeked;
 
 	u8 LidCheck;
-	u8 FastForward;

-	u8 FastBackward;

-

-	u8 AttenuatorLeft[2], AttenuatorRight[2];

+	u8 FastForward;
+	u8 FastBackward;
+
+	u8 AttenuatorLeft[2], AttenuatorRight[2];
 } cdrStruct;
 
 extern cdrStruct cdr;
 
 void cdrDecodedBufferInterrupt();
 
-void cdrReset();
-void cdrInterrupt();
-void cdrReadInterrupt();
-void cdrLidSeekInterrupt();

-void cdrPlayInterrupt();

+void cdrReset(void);
+void cdrInterrupt(void);
+void cdrReadInterrupt(void);
+void cdrLidSeekInterrupt(void);
+void cdrPlayInterrupt(void);
+void LidInterrupt(void);
 unsigned char cdrRead0(void);
 unsigned char cdrRead1(void);
 unsigned char cdrRead2(void);
diff --git a/libpcsxcore/debug.c b/libpcsxcore/debug.c
index 307a0020..5455e305 100644
--- a/libpcsxcore/debug.c
+++ b/libpcsxcore/debug.c
@@ -256,7 +256,7 @@ typedef struct breakpoint_s {
 
 static breakpoint_t *first = NULL;
 
-int add_breakpoint(int type, u32 address) {
+static int add_breakpoint(int type, u32 address) {
     breakpoint_t *bp = (breakpoint_t *)malloc(sizeof(breakpoint_t));
 
     bp->type = type;
@@ -278,7 +278,7 @@ int add_breakpoint(int type, u32 address) {
     return bp->number;
 }
 
-void delete_breakpoint(breakpoint_t * bp) {
+static void delete_breakpoint(breakpoint_t * bp) {
     if (bp == first) {
         if (bp->next == bp) {
             first = NULL;
@@ -293,11 +293,11 @@ void delete_breakpoint(breakpoint_t * bp) {
     free(bp);
 }
 
-breakpoint_t *next_breakpoint(breakpoint_t *bp) {
+static breakpoint_t *next_breakpoint(breakpoint_t *bp) {
     return bp->next != first ? bp->next : 0;
 }
 
-breakpoint_t *find_breakpoint(int number) {
+static breakpoint_t *find_breakpoint(int number) {
     breakpoint_t *p;
 
     for (p = first; p; p = next_breakpoint(p)) {
@@ -371,12 +371,12 @@ void DebugVSync() {
     ProcessCommands();
 }
 
-void MarkMap(u32 address, int mask) {
+static void MarkMap(u32 address, int mask) {
     if ((address & 0xff000000) != 0x80000000) return;
     MemoryMap[address & 0x001fffff] |= mask;
 }
 
-int IsMapMarked(u32 address, int mask) {
+static int IsMapMarked(u32 address, int mask) {
     return (MemoryMap[address & 0x001fffff] & mask) != 0;
 }
 
diff --git a/libpcsxcore/decode_xa.c b/libpcsxcore/decode_xa.c
index ee1dd6f3..abca4cc7 100644
--- a/libpcsxcore/decode_xa.c
+++ b/libpcsxcore/decode_xa.c
@@ -68,7 +68,7 @@ static int K1[4] = {
 #define BLKSIZ 28       /* block size (32 - 4 nibbles) */
 
 //===========================================
-void ADPCM_InitDecode(ADPCM_Decode_t *decp) {
+static void ADPCM_InitDecode(ADPCM_Decode_t *decp) {
 	decp->y0 = 0;
 	decp->y1 = 0;
 }
diff --git a/libpcsxcore/disr3000a.c b/libpcsxcore/disr3000a.c
index d99fe982..10f4b41c 100644
--- a/libpcsxcore/disr3000a.c
+++ b/libpcsxcore/disr3000a.c
@@ -1,337 +1,337 @@
-/***************************************************************************

- *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, 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.           *

- ***************************************************************************/

-

-/* 

-* R3000A disassembler.

-*/

-

-#include "psxcommon.h"

-

-char ostr[256];

-

-// Names of registers

-static char *disRNameGPR[] = {

-	"r0", "at", "v0", "v1", "a0", "a1", "a2", "a3",

-	"t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",

-	"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",

-	"t8", "t9", "k0", "k1", "gp", "sp", "fp", "ra"};

-

-static char *disRNameCP2D[] = {

-	"VXY0", "VZ0", "VXY1", "VZ1", "VXY2", "VZ2", "RGB", "OTZ",

-	"IR0", "IR1", "IR2", "IR3", "SXY0", "SXY1", "SXY2", "SXYP",

-	"SZ0", "SZ1", "SZ2", "SZ3", "RGB0", "RGB1", "RGB2", "RES1",

-	"MAC0", "MAC1", "MAC2", "MAC3", "IRGB", "ORGB", "LZCS", "LZCR"};

-

-static char *disRNameCP2C[] = {

-	"R11R12", "R13R21", "R22R23", "R31R32", "R33", "TRX", "TRY", "TRZ",

-	"L11L12", "L13L21", "L22L23", "L31L32", "L33", "RBK", "BBK", "GBK",

-	"LR1LR2", "LR3LG1", "LG2LG3", "LB1LB2", "LB3", "RFC", "GFC", "BFC",

-	"OFX", "OFY", "H", "DQA", "DQB", "ZSF3", "ZSF4", "FLAG"};

-

-char *disRNameCP0[] = {

-	"Index"     , "Random"    , "EntryLo0", "EntryLo1", "Context" , "PageMask"  , "Wired"     , "*Check me*",

-	"BadVAddr"  , "Count"     , "EntryHi" , "Compare" , "Status"  , "Cause"     , "ExceptPC"  , "PRevID"    ,

-	"Config"    , "LLAddr"    , "WatchLo" , "WatchHi" , "XContext", "*RES*"     , "*RES*"     , "*RES*"     ,

-	"*RES*"     , "*RES* "    , "PErr"    , "CacheErr", "TagLo"   , "TagHi"     , "ErrorEPC"  , "*RES*"     };

-

-

-// Type deffinition of our functions

-

-typedef char* (*TdisR3000AF)(u32 code, u32 pc);

-

-// These macros are used to assemble the disassembler functions

-#define MakeDisFg(fn, b) char* fn(u32 code, u32 pc) { b; return ostr; }

-#define MakeDisF(fn, b) \

-	static char* fn(u32 code, u32 pc) { \

-		sprintf (ostr, "%8.8x %8.8x:", pc, code); \

-		b; /*ostr[(strlen(ostr) - 1)] = 0;*/ return ostr; \

-	}

-

-

-#include "r3000a.h"

-

-#undef _Funct_

-#undef _Rd_

-#undef _Rt_

-#undef _Rs_

-#undef _Sa_

-#undef _Im_

-#undef _Target_

-

-#define _Funct_  ((code      ) & 0x3F) // The funct part of the instruction register 

-#define _Rd_     ((code >> 11) & 0x1F) // The rd part of the instruction register 

-#define _Rt_     ((code >> 16) & 0x1F) // The rt part of the instruction register 

-#define _Rs_     ((code >> 21) & 0x1F) // The rs part of the instruction register 

-#define _Sa_     ((code >>  6) & 0x1F) // The sa part of the instruction register

-#define _Im_     ( code & 0xFFFF)      // The immediate part of the instruction register

-

-#define _Target_  ((pc & 0xf0000000) + ((code & 0x03ffffff) * 4))

-#define _Branch_  (pc + 4 + ((short)_Im_ * 4))

-#define _OfB_     _Im_, _nRs_

-

-#define dName(i)	sprintf(ostr, "%s %-7s,", ostr, i)

-#define dGPR(i)		sprintf(ostr, "%s %8.8x (%s),", ostr, psxRegs.GPR.r[i], disRNameGPR[i])

-#define dCP0(i)		sprintf(ostr, "%s %8.8x (%s),", ostr, psxRegs.CP0.r[i], disRNameCP0[i])

-#define dCP2D(i)	sprintf(ostr, "%s %8.8x (%s),", ostr, psxRegs.CP2D.r[i], disRNameCP2D[i])

-#define dCP2C(i)	sprintf(ostr, "%s %8.8x (%s),", ostr, psxRegs.CP2C.r[i], disRNameCP2C[i])

-#define dHI()		sprintf(ostr, "%s %8.8x (%s),", ostr, psxRegs.GPR.n.hi, "hi")

-#define dLO()		sprintf(ostr, "%s %8.8x (%s),", ostr, psxRegs.GPR.n.lo, "lo")

-#define dImm()		sprintf(ostr, "%s %4.4x (%d),", ostr, _Im_, _Im_)

-#define dTarget()	sprintf(ostr, "%s %8.8x,", ostr, _Target_)

-#define dSa()		sprintf(ostr, "%s %2.2x (%d),", ostr, _Sa_, _Sa_)

-#define dOfB()		sprintf(ostr, "%s %4.4x (%8.8x (%s)),", ostr, _Im_, psxRegs.GPR.r[_Rs_], disRNameGPR[_Rs_])

-#define dOffset()	sprintf(ostr, "%s %8.8x,", ostr, _Branch_)

-#define dCode()		sprintf(ostr, "%s %8.8x,", ostr, (code >> 6) & 0xffffff)

-

-/*********************************************************

-* Arithmetic with immediate operand                      *

-* Format:  OP rt, rs, immediate                          *

-*********************************************************/

-MakeDisF(disADDI,		dName("ADDI");  dGPR(_Rt_); dGPR(_Rs_); dImm();)

-MakeDisF(disADDIU,		dName("ADDIU"); dGPR(_Rt_); dGPR(_Rs_); dImm();)

-MakeDisF(disANDI,		dName("ANDI");  dGPR(_Rt_); dGPR(_Rs_); dImm();)

-MakeDisF(disORI,		dName("ORI");   dGPR(_Rt_); dGPR(_Rs_); dImm();)

-MakeDisF(disSLTI,		dName("SLTI");  dGPR(_Rt_); dGPR(_Rs_); dImm();)

-MakeDisF(disSLTIU,		dName("SLTIU"); dGPR(_Rt_); dGPR(_Rs_); dImm();)

-MakeDisF(disXORI,		dName("XORI");  dGPR(_Rt_); dGPR(_Rs_); dImm();)

-

-/*********************************************************

-* Register arithmetic                                    *

-* Format:  OP rd, rs, rt                                 *

-*********************************************************/

-MakeDisF(disADD,		dName("ADD");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disADDU,		dName("ADDU"); dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disAND,		dName("AND");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disNOR,		dName("NOR");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disOR,			dName("OR");   dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disSLT,		dName("SLT");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disSLTU,		dName("SLTU"); dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disSUB,		dName("SUB");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disSUBU,		dName("SUBU"); dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disXOR,		dName("XOR");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)

-

-/*********************************************************

-* Register arithmetic & Register trap logic              *

-* Format:  OP rs, rt                                     *

-*********************************************************/

-MakeDisF(disDIV,		dName("DIV");   dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disDIVU,		dName("DIVU");  dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disMULT,		dName("MULT");  dGPR(_Rs_); dGPR(_Rt_);)

-MakeDisF(disMULTU,		dName("MULTU"); dGPR(_Rs_); dGPR(_Rt_);)

-

-/*********************************************************

-* Register branch logic                                  *

-* Format:  OP rs, offset                                 *

-*********************************************************/

-MakeDisF(disBGEZ,		dName("BGEZ");   dGPR(_Rs_); dOffset();)

-MakeDisF(disBGEZAL,		dName("BGEZAL"); dGPR(_Rs_); dOffset();)

-MakeDisF(disBGTZ,		dName("BGTZ");   dGPR(_Rs_); dOffset();)

-MakeDisF(disBLEZ,		dName("BLEZ");   dGPR(_Rs_); dOffset();)

-MakeDisF(disBLTZ,		dName("BLTZ");   dGPR(_Rs_); dOffset();)

-MakeDisF(disBLTZAL,		dName("BLTZAL"); dGPR(_Rs_); dOffset();)

-

-/*********************************************************

-* Shift arithmetic with constant shift                   *

-* Format:  OP rd, rt, sa                                 *

-*********************************************************/

-MakeDisF(disSLL,		if (code) { dName("SLL"); dGPR(_Rd_); dGPR(_Rt_); dSa(); } else { dName("NOP"); })

-MakeDisF(disSRA,		dName("SRA"); dGPR(_Rd_); dGPR(_Rt_); dSa();)

-MakeDisF(disSRL,		dName("SRL"); dGPR(_Rd_); dGPR(_Rt_); dSa();)

-

-/*********************************************************

-* Shift arithmetic with variant register shift           *

-* Format:  OP rd, rt, rs                                 *

-*********************************************************/

-MakeDisF(disSLLV,		dName("SLLV");  dGPR(_Rd_); dGPR(_Rt_); dGPR(_Rs_);)

-MakeDisF(disSRAV,		dName("SRAV");  dGPR(_Rd_); dGPR(_Rt_); dGPR(_Rs_);)

-MakeDisF(disSRLV,		dName("SRLV");  dGPR(_Rd_); dGPR(_Rt_); dGPR(_Rs_);)

-

-/*********************************************************

-* Load higher 16 bits of the first word in GPR with imm  *

-* Format:  OP rt, immediate                              *

-*********************************************************/

-MakeDisF(disLUI,		dName("LUI"); dGPR(_Rt_); dImm();)

-

-/*********************************************************

-* Move from HI/LO to GPR                                 *

-* Format:  OP rd                                         *

-*********************************************************/

-MakeDisF(disMFHI,		dName("MFHI"); dGPR(_Rd_); dHI();)

-MakeDisF(disMFLO,		dName("MFLO"); dGPR(_Rd_); dLO();)

-

-/*********************************************************

-* Move from GPR to HI/LO                                 *

-* Format:  OP rd                                         *

-*********************************************************/

-MakeDisF(disMTHI,		dName("MTHI"); dHI(); dGPR(_Rs_);)

-MakeDisF(disMTLO,		dName("MTLO"); dLO(); dGPR(_Rs_);)

-

-/*********************************************************

-* Special purpose instructions                           *

-* Format:  OP                                            *

-*********************************************************/

-MakeDisF(disBREAK,		dName("BREAK"))

-MakeDisF(disRFE,		dName("RFE"))

-MakeDisF(disSYSCALL,	dName("SYSCALL"))

-MakeDisF(disHLE,		dName("HLE"))

-

-

-MakeDisF(disRTPS,		dName("RTPS"))

-MakeDisF(disOP  ,		dName("OP"))

-MakeDisF(disNCLIP,		dName("NCLIP"))

-MakeDisF(disDPCS,		dName("DPCS"))

-MakeDisF(disINTPL,		dName("INTPL"))

-MakeDisF(disMVMVA,		dName("MVMVA"))

-MakeDisF(disNCDS ,		dName("NCDS"))

-MakeDisF(disCDP ,		dName("CDP"))

-MakeDisF(disNCDT ,		dName("NCDT"))

-MakeDisF(disNCCS ,		dName("NCCS"))

-MakeDisF(disCC  ,		dName("CC"))

-MakeDisF(disNCS ,		dName("NCS"))

-MakeDisF(disNCT  ,		dName("NCT"))

-MakeDisF(disSQR  ,		dName("SQR"))

-MakeDisF(disDCPL ,		dName("DCPL"))

-MakeDisF(disDPCT ,		dName("DPCT"))

-MakeDisF(disAVSZ3,		dName("AVSZ3"))

-MakeDisF(disAVSZ4,		dName("AVSZ4"))

-MakeDisF(disRTPT ,		dName("RTPT"))

-MakeDisF(disGPF  ,		dName("GPF"))

-MakeDisF(disGPL  ,		dName("GPL"))

-MakeDisF(disNCCT ,		dName("NCCT"))

-

-MakeDisF(disMFC2,		dName("MFC2"); dGPR(_Rt_);	dCP2C(_Rd_);)

-MakeDisF(disMTC2,		dName("MTC2"); dCP2C(_Rd_); dGPR(_Rt_);)

-MakeDisF(disCFC2,		dName("CFC2"); dGPR(_Rt_);	dCP2C(_Rd_);)

-MakeDisF(disCTC2,		dName("CTC2"); dCP2C(_Rd_); dGPR(_Rt_);)

-

-/*********************************************************

-* Register branch logic                                  *

-* Format:  OP rs, rt, offset                             *

-*********************************************************/

-MakeDisF(disBEQ,		dName("BEQ"); dGPR(_Rs_); dGPR(_Rt_); dOffset();)

-MakeDisF(disBNE,		dName("BNE"); dGPR(_Rs_); dGPR(_Rt_); dOffset();)

-

-/*********************************************************

-* Jump to target                                         *

-* Format:  OP target                                     *

-*********************************************************/

-MakeDisF(disJ,			dName("J");   dTarget();)

-MakeDisF(disJAL,		dName("JAL"); dTarget(); dGPR(31);)

-

-/*********************************************************

-* Register jump                                          *

-* Format:  OP rs, rd                                     *

-*********************************************************/

-MakeDisF(disJR,			dName("JR");   dGPR(_Rs_);)

-MakeDisF(disJALR,		dName("JALR"); dGPR(_Rs_); dGPR(_Rd_))

-

-/*********************************************************

-* Load and store for GPR                                 *

-* Format:  OP rt, offset(base)                           *

-*********************************************************/

-MakeDisF(disLB,			dName("LB");    dGPR(_Rt_);  dOfB();)

-MakeDisF(disLBU,		dName("LBU");   dGPR(_Rt_);  dOfB();)

-MakeDisF(disLH,			dName("LH");    dGPR(_Rt_);  dOfB();)

-MakeDisF(disLHU,		dName("LHU");   dGPR(_Rt_);  dOfB();)

-MakeDisF(disLW,			dName("LW");    dGPR(_Rt_);  dOfB();)

-MakeDisF(disLWL,		dName("LWL");   dGPR(_Rt_);  dOfB();)

-MakeDisF(disLWR,		dName("LWR");   dGPR(_Rt_);  dOfB();)

-MakeDisF(disLWC2,		dName("LWC2");  dCP2D(_Rt_);  dOfB();)

-MakeDisF(disSB,			dName("SB");    dGPR(_Rt_);  dOfB();)

-MakeDisF(disSH,			dName("SH");    dGPR(_Rt_);  dOfB();)

-MakeDisF(disSW,			dName("SW");    dGPR(_Rt_);  dOfB();)

-MakeDisF(disSWL,		dName("SWL");   dGPR(_Rt_);  dOfB();)

-MakeDisF(disSWR,		dName("SWR");   dGPR(_Rt_);  dOfB();)

-MakeDisF(disSWC2,		dName("SWC2");  dCP2D(_Rt_);  dOfB();)

-

-/*********************************************************

-* Moves between GPR and COPx                             *

-* Format:  OP rt, fs                                     *

-*********************************************************/

-MakeDisF(disMFC0,		dName("MFC0"); dGPR(_Rt_); dCP0(_Rd_);)

-MakeDisF(disMTC0,		dName("MTC0"); dCP0(_Rd_); dGPR(_Rt_);)

-MakeDisF(disCFC0,		dName("CFC0"); dGPR(_Rt_); dCP0(_Rd_);)

-MakeDisF(disCTC0,		dName("CTC0"); dCP0(_Rd_); dGPR(_Rt_);)

-

-/*********************************************************

-* Unknow instruction (would generate an exception)       *

-* Format:  ?                                             *

-*********************************************************/

-MakeDisF(disNULL,		dName("*** Bad OP ***");)

-

-

-TdisR3000AF disR3000A_SPECIAL[] = { // Subset of disSPECIAL

-	disSLL , disNULL , disSRL , disSRA , disSLLV   , disNULL  , disSRLV  , disSRAV ,

-	disJR  , disJALR , disNULL, disNULL, disSYSCALL, disBREAK , disNULL  , disNULL ,

-	disMFHI, disMTHI , disMFLO, disMTLO, disNULL   , disNULL  , disNULL  , disNULL ,

-	disMULT, disMULTU, disDIV , disDIVU, disNULL   , disNULL  , disNULL  , disNULL ,

-	disADD , disADDU , disSUB , disSUBU, disAND    , disOR    , disXOR   , disNOR  ,

-	disNULL, disNULL , disSLT , disSLTU, disNULL   , disNULL  , disNULL  , disNULL ,

-	disNULL, disNULL , disNULL, disNULL, disNULL   , disNULL  , disNULL   , disNULL ,

-	disNULL, disNULL , disNULL, disNULL, disNULL   , disNULL  , disNULL  , disNULL};

-

-MakeDisF(disSPECIAL,	disR3000A_SPECIAL[_Funct_](code, pc))

-

-TdisR3000AF disR3000A_BCOND[] = { // Subset of disBCOND

-	disBLTZ  , disBGEZ  , disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,

-	disNULL  , disNULL  , disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,

-	disBLTZAL, disBGEZAL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,

-	disNULL  , disNULL  , disNULL, disNULL, disNULL, disNULL, disNULL, disNULL};

-

-MakeDisF(disBCOND,	disR3000A_BCOND[_Rt_](code, pc))

-

-TdisR3000AF disR3000A_COP0[] = { // Subset of disCOP0

-	disMFC0, disNULL, disCFC0, disNULL, disMTC0, disNULL, disCTC0, disNULL,

-	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,

-	disRFE , disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,

-	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL};

-

-MakeDisF(disCOP0,		disR3000A_COP0[_Rs_](code, pc))

-

-TdisR3000AF disR3000A_BASIC[] = { // Subset of disBASIC (based on rs)

-	disMFC2, disNULL, disCFC2, disNULL, disMTC2, disNULL, disCTC2, disNULL,

-	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,

-	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,

-	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL};

-

-MakeDisF(disBASIC,		disR3000A_BASIC[_Rs_](code, pc))

-

-TdisR3000AF disR3000A_COP2[] = { // Subset of disR3000F_COP2 (based on funct)

-	disBASIC, disRTPS , disNULL , disNULL , disNULL, disNULL , disNCLIP, disNULL,

-	disNULL , disNULL , disNULL , disNULL , disOP  , disNULL , disNULL , disNULL,

-	disDPCS , disINTPL, disMVMVA, disNCDS , disCDP , disNULL , disNCDT , disNULL,

-	disNULL , disNULL , disNULL , disNCCS , disCC  , disNULL , disNCS  , disNULL,

-	disNCT  , disNULL , disNULL , disNULL , disNULL, disNULL , disNULL , disNULL,

-	disSQR  , disDCPL , disDPCT , disNULL , disNULL, disAVSZ3, disAVSZ4, disNULL, 

-	disRTPT , disNULL , disNULL , disNULL , disNULL, disNULL , disNULL , disNULL,

-	disNULL , disNULL , disNULL , disNULL , disNULL, disGPF  , disGPL  , disNCCT   };

-

-MakeDisF(disCOP2,		disR3000A_COP2[_Funct_](code, pc))

-

-TdisR3000AF disR3000A[] = {

-	disSPECIAL    , disBCOND     , disJ       , disJAL  , disBEQ , disBNE , disBLEZ , disBGTZ ,

-	disADDI       , disADDIU     , disSLTI    , disSLTIU, disANDI, disORI , disXORI , disLUI  ,

-	disCOP0       , disNULL      , disCOP2    , disNULL , disNULL, disNULL, disNULL , disNULL ,

-	disNULL       , disNULL      , disNULL    , disNULL , disNULL, disNULL, disNULL , disNULL ,

-	disLB         , disLH        , disLWL     , disLW   , disLBU , disLHU , disLWR  , disNULL ,

-	disSB         , disSH        , disSWL     , disSW   , disNULL, disNULL, disSWR  , disNULL , 

-	disNULL       , disNULL      , disLWC2    , disNULL , disNULL, disNULL, disNULL , disNULL ,

-	disNULL       , disNULL      , disSWC2    , disHLE  , disNULL, disNULL, disNULL , disNULL };

-

-MakeDisFg(disR3000AF,	disR3000A[code >> 26](code, pc))

+/***************************************************************************
+ *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, 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.           *
+ ***************************************************************************/
+
+/* 
+* R3000A disassembler.
+*/
+
+#include "psxcommon.h"
+
+char ostr[256];
+
+// Names of registers
+static char *disRNameGPR[] = {
+	"r0", "at", "v0", "v1", "a0", "a1", "a2", "a3",
+	"t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
+	"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
+	"t8", "t9", "k0", "k1", "gp", "sp", "fp", "ra"};
+
+static char *disRNameCP2D[] = {
+	"VXY0", "VZ0", "VXY1", "VZ1", "VXY2", "VZ2", "RGB", "OTZ",
+	"IR0", "IR1", "IR2", "IR3", "SXY0", "SXY1", "SXY2", "SXYP",
+	"SZ0", "SZ1", "SZ2", "SZ3", "RGB0", "RGB1", "RGB2", "RES1",
+	"MAC0", "MAC1", "MAC2", "MAC3", "IRGB", "ORGB", "LZCS", "LZCR"};
+
+static char *disRNameCP2C[] = {
+	"R11R12", "R13R21", "R22R23", "R31R32", "R33", "TRX", "TRY", "TRZ",
+	"L11L12", "L13L21", "L22L23", "L31L32", "L33", "RBK", "BBK", "GBK",
+	"LR1LR2", "LR3LG1", "LG2LG3", "LB1LB2", "LB3", "RFC", "GFC", "BFC",
+	"OFX", "OFY", "H", "DQA", "DQB", "ZSF3", "ZSF4", "FLAG"};
+
+char *disRNameCP0[] = {
+	"Index"     , "Random"    , "EntryLo0", "EntryLo1", "Context" , "PageMask"  , "Wired"     , "*Check me*",
+	"BadVAddr"  , "Count"     , "EntryHi" , "Compare" , "Status"  , "Cause"     , "ExceptPC"  , "PRevID"    ,
+	"Config"    , "LLAddr"    , "WatchLo" , "WatchHi" , "XContext", "*RES*"     , "*RES*"     , "*RES*"     ,
+	"*RES*"     , "*RES* "    , "PErr"    , "CacheErr", "TagLo"   , "TagHi"     , "ErrorEPC"  , "*RES*"     };
+
+
+// Type deffinition of our functions
+
+typedef char* (*TdisR3000AF)(u32 code, u32 pc);
+
+// These macros are used to assemble the disassembler functions
+#define MakeDisFg(fn, b) char* fn(u32 code, u32 pc) { return b; }
+#define MakeDisF(fn, b) \
+	static char* fn(u32 code, u32 pc) { \
+		char *s = ostr+sprintf (ostr, "%8.8x %8.8x:", pc, code); \
+		b; s[-1] = 0; return ostr; \
+	}
+
+
+#include "r3000a.h"
+
+#undef _Funct_
+#undef _Rd_
+#undef _Rt_
+#undef _Rs_
+#undef _Sa_
+#undef _Im_
+#undef _Target_
+
+#define _Funct_  ((code      ) & 0x3F) // The funct part of the instruction register 
+#define _Rd_     ((code >> 11) & 0x1F) // The rd part of the instruction register 
+#define _Rt_     ((code >> 16) & 0x1F) // The rt part of the instruction register 
+#define _Rs_     ((code >> 21) & 0x1F) // The rs part of the instruction register 
+#define _Sa_     ((code >>  6) & 0x1F) // The sa part of the instruction register
+#define _Im_     ( code & 0xFFFF)      // The immediate part of the instruction register
+
+#define _Target_  ((pc & 0xf0000000) + ((code & 0x03ffffff) * 4))
+#define _Branch_  (pc + 4 + ((short)_Im_ * 4))
+#define _OfB_     _Im_, _nRs_
+
+#define dName(i)	s+=sprintf(s, " %-7s ", i)
+#define dGPR(i)		s+=sprintf(s, " %8.8x (%d/%s),", psxRegs.GPR.r[i], i, disRNameGPR[i])
+#define dCP0(i)		s+=sprintf(s, " %8.8x (%d/%s),", psxRegs.CP0.r[i], i, disRNameCP0[i])
+#define dCP2D(i)	s+=sprintf(s, " %8.8x (%d/%s),", psxRegs.CP2D.r[i], i, disRNameCP2D[i])
+#define dCP2C(i)	s+=sprintf(s, " %8.8x (%d/%s),", psxRegs.CP2C.r[i], i, disRNameCP2C[i])
+#define dHI()		s+=sprintf(s, " %8.8x (hi),", psxRegs.GPR.n.hi)
+#define dLO()		s+=sprintf(s, " %8.8x (lo),", psxRegs.GPR.n.lo)
+#define dImm()		s+=sprintf(s, " %4.4x (%d),", _Im_, _Im_)
+#define dTarget()	s+=sprintf(s, " %8.8x,", _Target_)
+#define dSa()		s+=sprintf(s, " %2.2x (%d),", _Sa_, _Sa_)
+#define dOfB()		s+=sprintf(s, " %4.4x (%8.8x (%d/%s)),", _Im_, psxRegs.GPR.r[_Rs_], _Rs_, disRNameGPR[_Rs_])
+#define dOffset()	s+=sprintf(s, " %8.8x,", _Branch_)
+#define dCode()		s+=sprintf(s, " %8.8x,", (code >> 6) & 0xffffff)
+
+/*********************************************************
+* Arithmetic with immediate operand                      *
+* Format:  OP rt, rs, immediate                          *
+*********************************************************/
+MakeDisF(disADDI,		dName("ADDI");  dGPR(_Rt_); dGPR(_Rs_); dImm();)
+MakeDisF(disADDIU,		dName("ADDIU"); dGPR(_Rt_); dGPR(_Rs_); dImm();)
+MakeDisF(disANDI,		dName("ANDI");  dGPR(_Rt_); dGPR(_Rs_); dImm();)
+MakeDisF(disORI,		dName("ORI");   dGPR(_Rt_); dGPR(_Rs_); dImm();)
+MakeDisF(disSLTI,		dName("SLTI");  dGPR(_Rt_); dGPR(_Rs_); dImm();)
+MakeDisF(disSLTIU,		dName("SLTIU"); dGPR(_Rt_); dGPR(_Rs_); dImm();)
+MakeDisF(disXORI,		dName("XORI");  dGPR(_Rt_); dGPR(_Rs_); dImm();)
+
+/*********************************************************
+* Register arithmetic                                    *
+* Format:  OP rd, rs, rt                                 *
+*********************************************************/
+MakeDisF(disADD,		dName("ADD");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disADDU,		dName("ADDU"); dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disAND,		dName("AND");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disNOR,		dName("NOR");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disOR,			dName("OR");   dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disSLT,		dName("SLT");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disSLTU,		dName("SLTU"); dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disSUB,		dName("SUB");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disSUBU,		dName("SUBU"); dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disXOR,		dName("XOR");  dGPR(_Rd_); dGPR(_Rs_); dGPR(_Rt_);)
+
+/*********************************************************
+* Register arithmetic & Register trap logic              *
+* Format:  OP rs, rt                                     *
+*********************************************************/
+MakeDisF(disDIV,		dName("DIV");   dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disDIVU,		dName("DIVU");  dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disMULT,		dName("MULT");  dGPR(_Rs_); dGPR(_Rt_);)
+MakeDisF(disMULTU,		dName("MULTU"); dGPR(_Rs_); dGPR(_Rt_);)
+
+/*********************************************************
+* Register branch logic                                  *
+* Format:  OP rs, offset                                 *
+*********************************************************/
+MakeDisF(disBGEZ,		dName("BGEZ");   dGPR(_Rs_); dOffset();)
+MakeDisF(disBGEZAL,		dName("BGEZAL"); dGPR(_Rs_); dOffset();)
+MakeDisF(disBGTZ,		dName("BGTZ");   dGPR(_Rs_); dOffset();)
+MakeDisF(disBLEZ,		dName("BLEZ");   dGPR(_Rs_); dOffset();)
+MakeDisF(disBLTZ,		dName("BLTZ");   dGPR(_Rs_); dOffset();)
+MakeDisF(disBLTZAL,		dName("BLTZAL"); dGPR(_Rs_); dOffset();)
+
+/*********************************************************
+* Shift arithmetic with constant shift                   *
+* Format:  OP rd, rt, sa                                 *
+*********************************************************/
+MakeDisF(disSLL,		if (code) { dName("SLL"); dGPR(_Rd_); dGPR(_Rt_); dSa(); } else { dName("NOP"); })
+MakeDisF(disSRA,		dName("SRA"); dGPR(_Rd_); dGPR(_Rt_); dSa();)
+MakeDisF(disSRL,		dName("SRL"); dGPR(_Rd_); dGPR(_Rt_); dSa();)
+
+/*********************************************************
+* Shift arithmetic with variant register shift           *
+* Format:  OP rd, rt, rs                                 *
+*********************************************************/
+MakeDisF(disSLLV,		dName("SLLV");  dGPR(_Rd_); dGPR(_Rt_); dGPR(_Rs_);)
+MakeDisF(disSRAV,		dName("SRAV");  dGPR(_Rd_); dGPR(_Rt_); dGPR(_Rs_);)
+MakeDisF(disSRLV,		dName("SRLV");  dGPR(_Rd_); dGPR(_Rt_); dGPR(_Rs_);)
+
+/*********************************************************
+* Load higher 16 bits of the first word in GPR with imm  *
+* Format:  OP rt, immediate                              *
+*********************************************************/
+MakeDisF(disLUI,		dName("LUI"); dGPR(_Rt_); dImm();)
+
+/*********************************************************
+* Move from HI/LO to GPR                                 *
+* Format:  OP rd                                         *
+*********************************************************/
+MakeDisF(disMFHI,		dName("MFHI"); dGPR(_Rd_); dHI();)
+MakeDisF(disMFLO,		dName("MFLO"); dGPR(_Rd_); dLO();)
+
+/*********************************************************
+* Move from GPR to HI/LO                                 *
+* Format:  OP rd                                         *
+*********************************************************/
+MakeDisF(disMTHI,		dName("MTHI"); dHI(); dGPR(_Rs_);)
+MakeDisF(disMTLO,		dName("MTLO"); dLO(); dGPR(_Rs_);)
+
+/*********************************************************
+* Special purpose instructions                           *
+* Format:  OP                                            *
+*********************************************************/
+MakeDisF(disBREAK,		dName("BREAK"))
+MakeDisF(disRFE,		dName("RFE"))
+MakeDisF(disSYSCALL,	dName("SYSCALL"))
+MakeDisF(disHLE,		dName("HLE"))
+
+
+MakeDisF(disRTPS,		dName("RTPS"))
+MakeDisF(disOP  ,		dName("OP"))
+MakeDisF(disNCLIP,		dName("NCLIP"))
+MakeDisF(disDPCS,		dName("DPCS"))
+MakeDisF(disINTPL,		dName("INTPL"))
+MakeDisF(disMVMVA,		dName("MVMVA"))
+MakeDisF(disNCDS ,		dName("NCDS"))
+MakeDisF(disCDP ,		dName("CDP"))
+MakeDisF(disNCDT ,		dName("NCDT"))
+MakeDisF(disNCCS ,		dName("NCCS"))
+MakeDisF(disCC  ,		dName("CC"))
+MakeDisF(disNCS ,		dName("NCS"))
+MakeDisF(disNCT  ,		dName("NCT"))
+MakeDisF(disSQR  ,		dName("SQR"))
+MakeDisF(disDCPL ,		dName("DCPL"))
+MakeDisF(disDPCT ,		dName("DPCT"))
+MakeDisF(disAVSZ3,		dName("AVSZ3"))
+MakeDisF(disAVSZ4,		dName("AVSZ4"))
+MakeDisF(disRTPT ,		dName("RTPT"))
+MakeDisF(disGPF  ,		dName("GPF"))
+MakeDisF(disGPL  ,		dName("GPL"))
+MakeDisF(disNCCT ,		dName("NCCT"))
+
+MakeDisF(disMFC2,		dName("MFC2"); dGPR(_Rt_);	dCP2C(_Rd_);)
+MakeDisF(disMTC2,		dName("MTC2"); dCP2C(_Rd_); dGPR(_Rt_);)
+MakeDisF(disCFC2,		dName("CFC2"); dGPR(_Rt_);	dCP2C(_Rd_);)
+MakeDisF(disCTC2,		dName("CTC2"); dCP2C(_Rd_); dGPR(_Rt_);)
+
+/*********************************************************
+* Register branch logic                                  *
+* Format:  OP rs, rt, offset                             *
+*********************************************************/
+MakeDisF(disBEQ,		dName("BEQ"); dGPR(_Rs_); dGPR(_Rt_); dOffset();)
+MakeDisF(disBNE,		dName("BNE"); dGPR(_Rs_); dGPR(_Rt_); dOffset();)
+
+/*********************************************************
+* Jump to target                                         *
+* Format:  OP target                                     *
+*********************************************************/
+MakeDisF(disJ,			dName("J");   dTarget();)
+MakeDisF(disJAL,		dName("JAL"); dTarget(); dGPR(31);)
+
+/*********************************************************
+* Register jump                                          *
+* Format:  OP rs, rd                                     *
+*********************************************************/
+MakeDisF(disJR,			dName("JR");   dGPR(_Rs_);)
+MakeDisF(disJALR,		dName("JALR"); dGPR(_Rs_); dGPR(_Rd_))
+
+/*********************************************************
+* Load and store for GPR                                 *
+* Format:  OP rt, offset(base)                           *
+*********************************************************/
+MakeDisF(disLB,			dName("LB");    dGPR(_Rt_);  dOfB();)
+MakeDisF(disLBU,		dName("LBU");   dGPR(_Rt_);  dOfB();)
+MakeDisF(disLH,			dName("LH");    dGPR(_Rt_);  dOfB();)
+MakeDisF(disLHU,		dName("LHU");   dGPR(_Rt_);  dOfB();)
+MakeDisF(disLW,			dName("LW");    dGPR(_Rt_);  dOfB();)
+MakeDisF(disLWL,		dName("LWL");   dGPR(_Rt_);  dOfB();)
+MakeDisF(disLWR,		dName("LWR");   dGPR(_Rt_);  dOfB();)
+MakeDisF(disLWC2,		dName("LWC2");  dCP2D(_Rt_);  dOfB();)
+MakeDisF(disSB,			dName("SB");    dGPR(_Rt_);  dOfB();)
+MakeDisF(disSH,			dName("SH");    dGPR(_Rt_);  dOfB();)
+MakeDisF(disSW,			dName("SW");    dGPR(_Rt_);  dOfB();)
+MakeDisF(disSWL,		dName("SWL");   dGPR(_Rt_);  dOfB();)
+MakeDisF(disSWR,		dName("SWR");   dGPR(_Rt_);  dOfB();)
+MakeDisF(disSWC2,		dName("SWC2");  dCP2D(_Rt_);  dOfB();)
+
+/*********************************************************
+* Moves between GPR and COPx                             *
+* Format:  OP rt, fs                                     *
+*********************************************************/
+MakeDisF(disMFC0,		dName("MFC0"); dGPR(_Rt_); dCP0(_Rd_);)
+MakeDisF(disMTC0,		dName("MTC0"); dCP0(_Rd_); dGPR(_Rt_);)
+MakeDisF(disCFC0,		dName("CFC0"); dGPR(_Rt_); dCP0(_Rd_);)
+MakeDisF(disCTC0,		dName("CTC0"); dCP0(_Rd_); dGPR(_Rt_);)
+
+/*********************************************************
+* Unknow instruction (would generate an exception)       *
+* Format:  ?                                             *
+*********************************************************/
+MakeDisF(disNULL,		dName("*** Bad OP ***");)
+
+
+TdisR3000AF disR3000A_SPECIAL[] = { // Subset of disSPECIAL
+	disSLL , disNULL , disSRL , disSRA , disSLLV   , disNULL  , disSRLV  , disSRAV ,
+	disJR  , disJALR , disNULL, disNULL, disSYSCALL, disBREAK , disNULL  , disNULL ,
+	disMFHI, disMTHI , disMFLO, disMTLO, disNULL   , disNULL  , disNULL  , disNULL ,
+	disMULT, disMULTU, disDIV , disDIVU, disNULL   , disNULL  , disNULL  , disNULL ,
+	disADD , disADDU , disSUB , disSUBU, disAND    , disOR    , disXOR   , disNOR  ,
+	disNULL, disNULL , disSLT , disSLTU, disNULL   , disNULL  , disNULL  , disNULL ,
+	disNULL, disNULL , disNULL, disNULL, disNULL   , disNULL  , disNULL   , disNULL ,
+	disNULL, disNULL , disNULL, disNULL, disNULL   , disNULL  , disNULL  , disNULL};
+
+static MakeDisFg(disSPECIAL,	disR3000A_SPECIAL[_Funct_](code, pc))
+
+TdisR3000AF disR3000A_BCOND[] = { // Subset of disBCOND
+	disBLTZ  , disBGEZ  , disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,
+	disNULL  , disNULL  , disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,
+	disBLTZAL, disBGEZAL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,
+	disNULL  , disNULL  , disNULL, disNULL, disNULL, disNULL, disNULL, disNULL};
+
+static MakeDisFg(disBCOND,	disR3000A_BCOND[_Rt_](code, pc))
+
+TdisR3000AF disR3000A_COP0[] = { // Subset of disCOP0
+	disMFC0, disNULL, disCFC0, disNULL, disMTC0, disNULL, disCTC0, disNULL,
+	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,
+	disRFE , disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,
+	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL};
+
+static MakeDisFg(disCOP0,		disR3000A_COP0[_Rs_](code, pc))
+
+TdisR3000AF disR3000A_BASIC[] = { // Subset of disBASIC (based on rs)
+	disMFC2, disNULL, disCFC2, disNULL, disMTC2, disNULL, disCTC2, disNULL,
+	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,
+	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL,
+	disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL, disNULL};
+
+static MakeDisFg(disBASIC,		disR3000A_BASIC[_Rs_](code, pc))
+
+TdisR3000AF disR3000A_COP2[] = { // Subset of disR3000F_COP2 (based on funct)
+	disBASIC, disRTPS , disNULL , disNULL , disNULL, disNULL , disNCLIP, disNULL,
+	disNULL , disNULL , disNULL , disNULL , disOP  , disNULL , disNULL , disNULL,
+	disDPCS , disINTPL, disMVMVA, disNCDS , disCDP , disNULL , disNCDT , disNULL,
+	disNULL , disNULL , disNULL , disNCCS , disCC  , disNULL , disNCS  , disNULL,
+	disNCT  , disNULL , disNULL , disNULL , disNULL, disNULL , disNULL , disNULL,
+	disSQR  , disDCPL , disDPCT , disNULL , disNULL, disAVSZ3, disAVSZ4, disNULL, 
+	disRTPT , disNULL , disNULL , disNULL , disNULL, disNULL , disNULL , disNULL,
+	disNULL , disNULL , disNULL , disNULL , disNULL, disGPF  , disGPL  , disNCCT   };
+
+static MakeDisFg(disCOP2,		disR3000A_COP2[_Funct_](code, pc))
+
+TdisR3000AF disR3000A[] = {
+	disSPECIAL    , disBCOND     , disJ       , disJAL  , disBEQ , disBNE , disBLEZ , disBGTZ ,
+	disADDI       , disADDIU     , disSLTI    , disSLTIU, disANDI, disORI , disXORI , disLUI  ,
+	disCOP0       , disNULL      , disCOP2    , disNULL , disNULL, disNULL, disNULL , disNULL ,
+	disNULL       , disNULL      , disNULL    , disNULL , disNULL, disNULL, disNULL , disNULL ,
+	disLB         , disLH        , disLWL     , disLW   , disLBU , disLHU , disLWR  , disNULL ,
+	disSB         , disSH        , disSWL     , disSW   , disNULL, disNULL, disSWR  , disNULL , 
+	disNULL       , disNULL      , disLWC2    , disNULL , disNULL, disNULL, disNULL , disNULL ,
+	disNULL       , disNULL      , disSWC2    , disHLE  , disNULL, disNULL, disNULL , disNULL };
+
+MakeDisFg(disR3000AF,	disR3000A[code >> 26](code, pc))
diff --git a/libpcsxcore/ix86/iR3000A.c b/libpcsxcore/ix86/iR3000A.c
index 39b434bf..291a1770 100644
--- a/libpcsxcore/ix86/iR3000A.c
+++ b/libpcsxcore/ix86/iR3000A.c
@@ -344,6 +344,7 @@ static void iDumpRegs() {
 void iDumpBlock(char *ptr) {
 	FILE *f;
 	u32 i;
+	char buf[100];
 
 	SysPrintf("dump1 %x:%x, %x\n", psxRegs.pc, pc, psxRegs.cycle);
 
@@ -354,8 +355,8 @@ void iDumpBlock(char *ptr) {
 	f = fopen("dump1", "w");
 	fwrite(ptr, 1, (u32)x86Ptr - (u32)ptr, f);
 	fclose(f);
-	system("ndisasmw -u dump1");
-	fflush(stdout);
+	sprintf(buf, "objdump -m i386 -M i386 -D -b binary --adjust-vma=0x%lx dump1", (unsigned long)ptr);
+	system(buf);
 }
 
 #define REC_FUNC(f) \
@@ -1551,9 +1552,6 @@ static void recLW() {
 	resp+= 4;
 }
 
-extern u32 LWL_MASK[4];
-extern u32 LWL_SHIFT[4];
-
 void iLWLk(u32 shift) {
 	if (IsConst(_Rt_)) {
 		MOV32ItoR(ECX, iRegs[_Rt_].k);
@@ -1703,9 +1701,6 @@ static void recLWBlock(int count) {
 	resp = respsave;
 }
 
-extern u32 LWR_MASK[4];
-extern u32 LWR_SHIFT[4];
-
 void iLWRk(u32 shift) {
 	if (IsConst(_Rt_)) {
 		MOV32ItoR(ECX, iRegs[_Rt_].k);
@@ -2051,9 +2046,6 @@ static void recSWBlock(int count) {
 	resp = respsave;
 }
 
-extern u32 SWL_MASK[4];
-extern u32 SWL_SHIFT[4];
-
 void iSWLk(u32 shift) {
 	if (IsConst(_Rt_)) {
 		MOV32ItoR(ECX, iRegs[_Rt_].k);
@@ -2133,9 +2125,6 @@ void recSWL() {
 	resp+= 8;
 }
 
-extern u32 SWR_MASK[4];
-extern u32 SWR_SHIFT[4];
-
 void iSWRk(u32 shift) {
 	if (IsConst(_Rt_)) {
 		MOV32ItoR(ECX, iRegs[_Rt_].k);
diff --git a/libpcsxcore/ix86/ix86.c b/libpcsxcore/ix86/ix86.c
index 1525ac37..ef0e0d3a 100644
--- a/libpcsxcore/ix86/ix86.c
+++ b/libpcsxcore/ix86/ix86.c
@@ -54,7 +54,7 @@ void x86SetJ32(u32 *j32) {
 
 void x86Align(int bytes) {
 	// fordward align
-	x86Ptr = (s8*)(((u32)x86Ptr + bytes) & ~(bytes - 1));
+	x86Ptr = (s8*)(((u32)x86Ptr + bytes - 1) & ~(bytes - 1));
 }
 
 #define SIB 4
diff --git a/libpcsxcore/ix86_64/iR3000A-64.c b/libpcsxcore/ix86_64/iR3000A-64.c
index fe146589..7f9a35cb 100644
--- a/libpcsxcore/ix86_64/iR3000A-64.c
+++ b/libpcsxcore/ix86_64/iR3000A-64.c
@@ -354,9 +354,10 @@ static void iDumpRegs() {
 	}
 }
 
-void iDumpBlock(char *ptr) {
+static void iDumpBlock(s8 *ptr) {
 	FILE *f;
 	u32 i;
+	char buf[200];
 
 	SysPrintf("dump1 %x:%x, %x\n", psxRegs.pc, pc, psxRegs.cycle);
 
@@ -364,11 +365,31 @@ void iDumpBlock(char *ptr) {
 		SysPrintf("%s\n", disR3000AF(PSXMu32(i), i));
 
 	fflush(stdout);
+#if 1
 	f = fopen("dump1", "w");
-	fwrite(ptr, 1, (uptr)x86Ptr - (uptr)ptr, f);
-	fclose(f);
-	//system("ndisasm -b64 dump1");
-	fflush(stdout);
+	if(f) {
+		/* errors don't really matter, but gcc complains if ignored */
+		int err;
+		err = fwrite(ptr, (uptr)x86Ptr - (uptr)ptr, 1, f) != 1;
+		err = fclose(f) != 0 || err;
+		if(!err) {
+			sprintf(buf, "objdump -m i386 -M x86-64 -D -b binary --adjust-vma=0x%lx dump1", (unsigned long)ptr);
+			err = system(buf);
+		} else
+			perror("dump1");
+		remove("dump1");
+	}
+#else
+	/* probably pointless; branch targets are still not symbols */
+	sprintf(buf,
+		"gdb --batch --quiet"
+		" -ex 'set verbose 0'"
+		" -ex 'set confirm 0'"
+		" -ex 'attach %d'"
+		" -ex 'disas/r %p,%p'"
+		, getpid(), ptr, x86Ptr - 1);
+	system(buf);
+#endif
 }
 
 #define REC_FUNC(f) \
diff --git a/libpcsxcore/ix86_64/ix86-64.c b/libpcsxcore/ix86_64/ix86-64.c
index 582b3a40..31ae8ea8 100644
--- a/libpcsxcore/ix86_64/ix86-64.c
+++ b/libpcsxcore/ix86_64/ix86-64.c
@@ -119,7 +119,7 @@ void CheckX86Ptr( void )
 {
 }
 
-void writeVAROP(unsigned opl, u64 op)
+static void writeVAROP(unsigned opl, u64 op)
 {
 	while (opl--)
 	{
@@ -177,14 +177,14 @@ void SET8R( int cc, int to )
 	write8( 0xC0 | ( to ) );
 }
 
-u8* J8Rel( int cc, int to )
+u8* J8Rel( int cc, u8 to )
 {
 	write8( cc );
     write8( to );
-    return x86Ptr - 1;
+    return (u8 *)x86Ptr - 1;
 }
 
-u16* J16Rel( int cc, u32 to )
+u16* J16Rel( int cc, u16 to )
 {
 	write16( 0x0F66 );
 	write8( cc );
@@ -214,7 +214,7 @@ void CMOV32MtoR( int cc, x86IntRegType to, uptr from )
 }
 
 ////////////////////////////////////////////////////
-void x86SetPtr( char* ptr ) 
+void x86SetPtr( s8* ptr )
 {
 	x86Ptr = ptr;
 }
@@ -2364,7 +2364,7 @@ u8* JMP8( u8 to )
 {
 	write8( 0xEB ); 
 	write8( to );
-	return x86Ptr - 1;
+	return (u8 *)x86Ptr - 1;
 }
 
 /* jmp rel32 */
@@ -2687,7 +2687,7 @@ void CMP64I32toR( x86IntRegType to, u32 from )
 /* cmp m64 to r64 */
 void CMP64MtoR( x86IntRegType to, uptr from ) 
 {
-	MEMADDR_OP(1, VAROP1(0x3B), true, 2, from, 0);
+	MEMADDR_OP(1, VAROP1(0x3B), true, to, from, 0);
 }
 
 // cmp r64 to r64 
@@ -2935,7 +2935,7 @@ void SETG8R( x86IntRegType to ) { SET8R(0x9f, to); }
 // seta r8 
 void SETA8R( x86IntRegType to ) { SET8R(0x97, to); }
 // setae r8 
-void SETAE8R( x86IntRegType to ) { SET8R(0x99, to); }
+void SETAE8R( x86IntRegType to ) { SET8R(0x93, to); }
 /* setb r8 */
 void SETB8R( x86IntRegType to ) { SET8R( 0x92, to ); }
 /* setb r8 */
diff --git a/libpcsxcore/ix86_64/ix86-64.h b/libpcsxcore/ix86_64/ix86-64.h
index 009fa5a1..95945a0f 100644
--- a/libpcsxcore/ix86_64/ix86-64.h
+++ b/libpcsxcore/ix86_64/ix86-64.h
@@ -191,9 +191,9 @@ typedef struct {
    u32 x86Flags;	   // Feature Flags
    u32 x86EFlags;	   // Extended Feature Flags
    //all the above returns hex values
-   s8  x86ID[16];	   // Vendor ID  //the vendor creator (in %s)
-   s8  x86Type[20];   //cpu type in char format //the cpu type (in %s)
-   s8  x86Fam[50];    // family in char format //the original cpu name string (in %s)
+   char x86ID[16];	   // Vendor ID  //the vendor creator (in %s)
+   char x86Type[20];   //cpu type in char format //the cpu type (in %s)
+   char x86Fam[50];    // family in char format //the original cpu name string (in %s)
    u32 cpuspeed;      // speed of cpu //this will give cpu speed (in %d)
 } CPUINFO;
 
@@ -228,7 +228,7 @@ extern u32 *j32Ptr[32];
 #define RexB(w, base) RexRXB(w, 0, 0, base)
 #define RexRB(w, reg, base) RexRXB(w, reg, 0, base)
 
-void x86SetPtr( char *ptr );
+void x86SetPtr( s8 *ptr );
 void x86Shutdown( void );
 
 void x86SetJ8( u8 *j8 );
@@ -245,7 +245,8 @@ u64 GetCPUTick( void );
 #define ModRM(mod, rm, reg) write8( ( mod << 6 ) | ( (rm & 7) << 3 ) | ( reg & 7 ) )
 #define SibSB(ss, rm, index) write8( ( ss << 6 ) | ( rm << 3 ) | ( index ) )
 void SET8R( int cc, int to );
-u8* J8Rel( int cc, int to );
+u8* J8Rel( int cc, u8 to );
+u16* J16Rel( int cc, u16 to );
 u32* J32Rel( int cc, u32 to );
 void CMOV32RtoR( int cc, int to, int from );
 void CMOV32MtoR( int cc, int to, uptr from );
@@ -478,6 +479,8 @@ void CMOVLE32MtoR( x86IntRegType to, uptr from );
 void ADD64ItoR( x86IntRegType to, u32 from );
 // add m64 to r64 
 void ADD64MtoR( x86IntRegType to, uptr from );
+// add r64 to r64
+void ADD64RtoR( x86IntRegType to, x86IntRegType from );
 
 // add imm32 to r32 
 void ADD32ItoR( x86IntRegType to, u32 from );
@@ -529,6 +532,7 @@ void INC16M( uptr to );
 // sub m64 to r64 
 void SUB64MtoR( x86IntRegType to, uptr from );
 void SUB64ItoR( x86IntRegType to, u32 from );
+void SUB64RtoR( x86IntRegType to, x86IntRegType from );
 
 // sub imm32 to r32 
 void SUB32ItoR( x86IntRegType to, u32 from );
@@ -795,6 +799,10 @@ u8*  JMP8( u8 to );
 
 // jmp rel32 
 u32* JMP32( uptr to );
+
+// jump rel8/rel32 (back jump only)
+u8* JMP( uptr to );
+
 // jmp r32 (r64 if __x86_64__)
 void JMPR( x86IntRegType to );
 // jmp m32 
@@ -1751,6 +1759,7 @@ void SSE2EMU_MOVD_XMM_to_M32( uptr to, x86SSERegType from );
 void SSE2EMU_MOVD_R_to_XMM( x86SSERegType to, x86IntRegType from );
 
 ////////////////////////////////////////////////////
+void CheckX86Ptr(void);
 #ifdef _DEBUG
 #define WRITECHECK() CheckX86Ptr()
 #else
@@ -1769,6 +1778,9 @@ void SSE2EMU_MOVD_R_to_XMM( x86SSERegType to, x86IntRegType from );
 #define write32( val ) writeVAL((u32)(val))
 #define write64( val ) writeVAL((u64)(val))
 
+void WriteRmOffset(x86IntRegType to, int offset);
+void WriteRmOffsetFrom(x86IntRegType to, x86IntRegType from, int offset);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/libpcsxcore/ix86_64/ix86_cpudetect.c b/libpcsxcore/ix86_64/ix86_cpudetect.c
index 664e6b7d..76305974 100644
--- a/libpcsxcore/ix86_64/ix86_cpudetect.c
+++ b/libpcsxcore/ix86_64/ix86_cpudetect.c
@@ -1,492 +1,492 @@
-/*  Cpudetection lib 

- *  Copyright (C) 2002-2003  Pcsx2 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

- */

-

-#ifdef __x86_64__

-

-#if defined (_WIN32)

-#include <windows.h>

-#endif

-

-#include <string.h>

-#include <stdio.h>

-

-#include "ix86-64.h"

-

-#if defined (_MSC_VER) && _MSC_VER >= 1400

-

-   void __cpuid(int* CPUInfo, int InfoType);

-   unsigned __int64 __rdtsc();

-

-   #pragma intrinsic(__cpuid)

-   #pragma intrinsic(__rdtsc)

-

-#endif

-

-CAPABILITIES cpucaps;

-CPUINFO cpuinfo;

-

-#define cpuid(cmd,a,b,c,d) \

-  __asm__ __volatile__("cpuid" \

-		: "=a" (a), "=b" (b), "=c" (c), "=d" (d)  : "0" (cmd))

-

-static s32 iCpuId( u32 cmd, u32 *regs ) 

-{

-   int flag=1;

-

-#if defined (_MSC_VER) && _MSC_VER >= 1400

-

-   __cpuid( regs, cmd );

-

-   return 0;

-

-#elif defined (_MSC_VER) 

-

-#ifdef __x86_64__

-   assert(0);

-#else // __x86_64__

-   __asm 

-   {

-      push ebx;

-      push edi;

-

-      pushfd;

-      pop eax;

-      mov edx, eax;

-      xor eax, 1 << 21;

-      push eax;

-      popfd;

-      pushfd;

-      pop eax;

-      xor eax, edx;

-      mov flag, eax;

-   }

-   if ( ! flag )

-   {

-      return -1;

-   }

-

-   __asm 

-   {

-      mov eax, cmd;

-      cpuid;

-      mov edi, [regs]

-      mov [edi], eax;

-      mov [edi+4], ebx;

-      mov [edi+8], ecx;

-      mov [edi+12], edx;

-

-      pop edi;

-      pop ebx;

-   }

-#endif // __x86_64__

-   return 0;

-

-

-#else

-

-#ifndef __x86_64__

-   // see if we can use cpuid

-   __asm__ __volatile__ (

-      "sub $0x18, %%esp\n"

-      "pushf\n"

-      "pop %%eax\n"

-      "mov %%eax, %%edx\n"

-      "xor $0x200000, %%eax\n"

-      "push %%eax\n"

-      "popf\n"

-      "pushf\n"

-      "pop %%eax\n"

-      "xor %%edx, %%eax\n"

-      "mov %%eax, %0\n"

-	  "add $0x18, %%esp\n"

-      : "=r"(flag) :

-   );

-#endif

-

-   if ( !flag )

-       return -1;

-

-   cpuid(cmd, regs[0], regs[1], regs[2], regs[3]);

-   return 0;

-#endif // _MSC_VER

-}

-

-u64 GetCPUTick( void ) 

-{

-#if defined (_MSC_VER) && _MSC_VER >= 1400

-

-   return __rdtsc();

-

-#elif defined(__MSCW32__) && !defined(__x86_64__)

-

-   __asm rdtsc;

-

-#else

-

-   u32 _a, _d;

-	__asm__ __volatile__ ("rdtsc" : "=a"(_a), "=d"(_d));

-	return (u64)_a | ((u64)_d << 32);

-

-#endif

-}

-

-#if defined(__LINUX__) || defined(__APPLE__)

-

-#include <sys/time.h>

-#include <errno.h>

-//*

-unsigned long timeGetTime2()

-{

- struct timeval tv;

- gettimeofday(&tv, 0);                                 // well, maybe there are better ways

- return (unsigned long)tv.tv_sec * 1000 + tv.tv_usec/1000;            // to do that, but at least it works

-}

-//*/

-#endif

-

-s64 CPUSpeedHz( unsigned int time )

-{

-   s64 timeStart, 

-            timeStop;

-   s64 startTick, 

-            endTick;

-   s64 overhead;

-

-   if( ! cpucaps.hasTimeStampCounter )

-   {

-      return 0; //check if function is supported

-   }

-

-	overhead = GetCPUTick() - GetCPUTick();

-	

-	timeStart = timeGetTime2( );

-	while( timeGetTime2( ) == timeStart ) 

-   {

-      timeStart = timeGetTime2( );

-   }

-	for(;;)

-	{

-		timeStop = timeGetTime2( );

-		if ( ( timeStop - timeStart ) > 1 )	

-		{

-			startTick = GetCPUTick( );

-			break;

-		}

-	}

-

-	timeStart = timeStop;

-	for(;;)

-	{

-		timeStop = timeGetTime2( );

-		if ( ( timeStop - timeStart ) > time )	

-		{

-			endTick = GetCPUTick( );

-			break;

-		}

-	}

-

-	return (s64)( ( endTick - startTick ) + ( overhead ) );

-}

-

-////////////////////////////////////////////////////

-void cpudetectInit( void ) 

-{

-   u32 regs[ 4 ];

-   u32 cmds;

-   u32 AMDspeed;

-   s8 AMDspeedString[10];

-   int cputype=0;            // Cpu type

-   //AMD 64 STUFF

-   u32 x86_64_8BITBRANDID;

-   u32 x86_64_12BITBRANDID; 

-   memset( cpuinfo.x86ID, 0, sizeof( cpuinfo.x86ID ) );

-   cpuinfo.x86Family = 0;

-   cpuinfo.x86Model  = 0;

-   cpuinfo.x86PType  = 0;

-   cpuinfo.x86StepID = 0;

-   cpuinfo.x86Flags  = 0;

-   cpuinfo.x86EFlags = 0;

-   

-   if ( iCpuId( 0, regs ) == -1 ) return;

-

-   cmds = regs[ 0 ];

-   ((u32*)cpuinfo.x86ID)[ 0 ] = regs[ 1 ];

-   ((u32*)cpuinfo.x86ID)[ 1 ] = regs[ 3 ];

-   ((u32*)cpuinfo.x86ID)[ 2 ] = regs[ 2 ];

-   if ( cmds >= 0x00000001 ) 

-   {

-      if ( iCpuId( 0x00000001, regs ) != -1 )

-      {

-         cpuinfo.x86StepID =  regs[ 0 ]        & 0xf;

-         cpuinfo.x86Model  = (regs[ 0 ] >>  4) & 0xf;

-         cpuinfo.x86Family = (regs[ 0 ] >>  8) & 0xf;

-         cpuinfo.x86PType  = (regs[ 0 ] >> 12) & 0x3;

-         x86_64_8BITBRANDID = regs[1] & 0xff;

-         cpuinfo.x86Flags  =  regs[ 3 ];

-      }

-   }

-   if ( iCpuId( 0x80000000, regs ) != -1 )

-   {

-      cmds = regs[ 0 ];

-      if ( cmds >= 0x80000001 ) 

-      {

-		 if ( iCpuId( 0x80000001, regs ) != -1 )

-         {

-			x86_64_12BITBRANDID = regs[1] & 0xfff;

-            cpuinfo.x86EFlags = regs[ 3 ];

-            

-         }

-      }

-   }

-   switch(cpuinfo.x86PType)

-   {

-      case 0:

-         strcpy( cpuinfo.x86Type, "Standard OEM");

-         break;

-      case 1:

-         strcpy( cpuinfo.x86Type, "Overdrive");

-         break;

-      case 2:

-         strcpy( cpuinfo.x86Type, "Dual");

-         break;

-      case 3:

-         strcpy( cpuinfo.x86Type, "Reserved");

-         break;

-      default:

-         strcpy( cpuinfo.x86Type, "Unknown");

-         break;

-   }

-   if ( cpuinfo.x86ID[ 0 ] == 'G' ){ cputype=0;}//trick lines but if you know a way better ;p

-   if ( cpuinfo.x86ID[ 0 ] == 'A' ){ cputype=1;}

-   

-   if ( cputype == 0 ) //intel cpu

-   {

-      if( ( cpuinfo.x86Family >= 7 ) && ( cpuinfo.x86Family < 15 ) )

-      {

-         strcpy( cpuinfo.x86Fam, "Intel P6 family (Not PIV and Higher then PPro" );

-      }

-      else

-      {

-         switch( cpuinfo.x86Family )

-         {     

-            // Start at 486 because if it's below 486 there is no cpuid instruction

-            case 4:

-               strcpy( cpuinfo.x86Fam, "Intel 486" );

-               break;

-            case 5:     

-               switch( cpuinfo.x86Model )

-               {

-               case 4:

-               case 8:     // 0.25 µm

-                  strcpy( cpuinfo.x86Fam, "Intel Pentium (MMX)");

-                  break;

-               default:

-                  strcpy( cpuinfo.x86Fam, "Intel Pentium" );

-               }

-               break;

-            case 6:     

-               switch( cpuinfo.x86Model )

-               {

-               case 0:     // Pentium pro (P6 A-Step)

-               case 1:     // Pentium pro

-                  strcpy( cpuinfo.x86Fam, "Intel Pentium Pro" );

-                  break;

-

-               case 2:     // 66 MHz FSB

-               case 5:     // Xeon/Celeron (0.25 µm)

-               case 6:     // Internal L2 cache

-                  strcpy( cpuinfo.x86Fam, "Intel Pentium II" );

-                  break;

-

-               case 7:     // Xeon external L2 cache

-               case 8:     // Xeon/Celeron with 256 KB on-die L2 cache

-               case 10:    // Xeon/Celeron with 1 or 2 MB on-die L2 cache

-               case 11:    // Xeon/Celeron with Tualatin core, on-die cache

-                  strcpy( cpuinfo.x86Fam, "Intel Pentium III" );

-                  break;

-			   case 15:    // Core 2 Duo Allendale/Conroe

-				  strcpy( cpuinfo.x86Fam, "Intel Core 2 Duo" );

-				  break;

-

-               default:

-                  strcpy( cpuinfo.x86Fam, "Intel Pentium Pro (Unknown)" );

-               }

-               break;

-            case 15:

-               switch( cpuinfo.x86Model )

-               {

-               case 0:     // Willamette (A-Step)

-               case 1:     // Willamette 

-                  strcpy( cpuinfo.x86Fam, "Willamette Intel Pentium IV" );

-                  break;

-               case 2:     // Northwood 

-                  strcpy( cpuinfo.x86Fam, "Northwood Intel Pentium IV" );

-                  break;

-

-               default:

-                  strcpy( cpuinfo.x86Fam, "Intel Pentium IV (Unknown)" );

-                  break;

-               }

-               break;

-            default:

-               strcpy( cpuinfo.x86Fam, "Unknown Intel CPU" );

-         }

-      }

-   }

-   else if ( cputype == 1 ) //AMD cpu

-   {

-      if( cpuinfo.x86Family >= 7 )

-      {

-		  if((x86_64_12BITBRANDID !=0) || (x86_64_8BITBRANDID !=0))

-		  {

-		    if(x86_64_8BITBRANDID == 0 )

-		    {

-               switch((x86_64_12BITBRANDID >>6)& 0x3f)

-			   {

-			    case 4:

-				 strcpy(cpuinfo.x86Fam,"AMD Athlon(tm) 64 Processor");

-                 AMDspeed = 22 + (x86_64_12BITBRANDID & 0x1f);

-				 //AMDspeedString = strtol(AMDspeed, (char**)NULL,10);

-				 sprintf(AMDspeedString," %d",AMDspeed);

-				 strcat(AMDspeedString,"00+");

-				 strcat(cpuinfo.x86Fam,AMDspeedString);

-				 break;

-			    case 12: 

-				 strcpy(cpuinfo.x86Fam,"AMD Opteron(tm) Processor");

-				 break;

-			    case 5:

-				  strcpy( cpuinfo.x86Fam, "AMD Athlon X2 Processor" );

-				  AMDspeed = 22 + (x86_64_12BITBRANDID & 0x1f);

-				 //AMDspeedString = strtol(AMDspeed, (char**)NULL,10);

-				 sprintf(AMDspeedString," %d",AMDspeed);

-				 strcat(AMDspeedString,"00+");

-				 strcat(cpuinfo.x86Fam,AMDspeedString);

-                  break;

-			   case 44:

-				   strcpy( cpuinfo.x86Fam, "AMD Opteron(tm) Dual Core Processor" );

-                  break;

-			    default:

-				   strcpy(cpuinfo.x86Fam,"Unknown AMD 64 proccesor");

-				   

-			    }

-		     }

-		     else //8bit brand id is non zero

-		     {

-                strcpy(cpuinfo.x86Fam,"Unsupported yet AMD64 cpu");

-		     }

-		  }

-		  else

-		  {		 

-			  strcpy( cpuinfo.x86Fam, "AMD K7+ Processor" );

-		  }

-      }

-      else

-      {

-         switch ( cpuinfo.x86Family )

-         {

-            case 4:

-               switch( cpuinfo.x86Model )

-               {

-               case 14: 

-               case 15:       // Write-back enhanced

-                  strcpy( cpuinfo.x86Fam, "AMD 5x86 Processor" );

-                  break;

-

-               case 3:        // DX2

-               case 7:        // Write-back enhanced DX2

-               case 8:        // DX4

-               case 9:        // Write-back enhanced DX4

-                  strcpy( cpuinfo.x86Fam, "AMD 486 Processor" );

-                  break;

-			   			   

-

-               default:

-                  strcpy( cpuinfo.x86Fam, "AMD Unknown Processor" );

-

-               }

-               break;

-

-            case 5:     

-               switch( cpuinfo.x86Model)

-               {

-               case 0:     // SSA 5 (75, 90 and 100 Mhz)

-               case 1:     // 5k86 (PR 120 and 133 MHz)

-               case 2:     // 5k86 (PR 166 MHz)

-               case 3:     // K5 5k86 (PR 200 MHz)

-                  strcpy( cpuinfo.x86Fam, "AMD K5 Processor" );

-                  break;

-

-               case 6:     

-               case 7:     // (0.25 µm)

-               case 8:     // K6-2

-               case 9:     // K6-III

-               case 14:    // K6-2+ / K6-III+

-                  strcpy( cpuinfo.x86Fam, "AMD K6 Series Processor" );

-                  break;

-

-               default:

-                  strcpy( cpuinfo.x86Fam, "AMD Unknown Processor" );

-               }

-               break;

-            case 6:     

-               strcpy( cpuinfo.x86Fam, "AMD Athlon XP Processor" );

-               break;

-            default:

-               strcpy( cpuinfo.x86Fam, "Unknown AMD CPU" ); 

-         }

-      }

-   }

-   //capabilities

-   cpucaps.hasFloatingPointUnit                         = ( cpuinfo.x86Flags >>  0 ) & 1;

-   cpucaps.hasVirtual8086ModeEnhancements               = ( cpuinfo.x86Flags >>  1 ) & 1;

-   cpucaps.hasDebuggingExtensions                       = ( cpuinfo.x86Flags >>  2 ) & 1;

-   cpucaps.hasPageSizeExtensions                        = ( cpuinfo.x86Flags >>  3 ) & 1;

-   cpucaps.hasTimeStampCounter                          = ( cpuinfo.x86Flags >>  4 ) & 1;

-   cpucaps.hasModelSpecificRegisters                    = ( cpuinfo.x86Flags >>  5 ) & 1;

-   cpucaps.hasPhysicalAddressExtension                  = ( cpuinfo.x86Flags >>  6 ) & 1;

-   cpucaps.hasMachineCheckArchitecture                  = ( cpuinfo.x86Flags >>  7 ) & 1;

-   cpucaps.hasCOMPXCHG8BInstruction                     = ( cpuinfo.x86Flags >>  8 ) & 1;

-   cpucaps.hasAdvancedProgrammableInterruptController   = ( cpuinfo.x86Flags >>  9 ) & 1;

-   cpucaps.hasSEPFastSystemCall                         = ( cpuinfo.x86Flags >> 11 ) & 1;

-   cpucaps.hasMemoryTypeRangeRegisters                  = ( cpuinfo.x86Flags >> 12 ) & 1;

-   cpucaps.hasPTEGlobalFlag                             = ( cpuinfo.x86Flags >> 13 ) & 1;

-   cpucaps.hasMachineCheckArchitecture                  = ( cpuinfo.x86Flags >> 14 ) & 1;

-   cpucaps.hasConditionalMoveAndCompareInstructions     = ( cpuinfo.x86Flags >> 15 ) & 1;

-   cpucaps.hasFGPageAttributeTable                      = ( cpuinfo.x86Flags >> 16 ) & 1;

-   cpucaps.has36bitPageSizeExtension                    = ( cpuinfo.x86Flags >> 17 ) & 1;

-   cpucaps.hasProcessorSerialNumber                     = ( cpuinfo.x86Flags >> 18 ) & 1;

-   cpucaps.hasCFLUSHInstruction                         = ( cpuinfo.x86Flags >> 19 ) & 1;

-   cpucaps.hasDebugStore                                = ( cpuinfo.x86Flags >> 21 ) & 1;

-   cpucaps.hasACPIThermalMonitorAndClockControl         = ( cpuinfo.x86Flags >> 22 ) & 1;

-   cpucaps.hasMultimediaExtensions                      = ( cpuinfo.x86Flags >> 23 ) & 1; //mmx

-   cpucaps.hasFastStreamingSIMDExtensionsSaveRestore    = ( cpuinfo.x86Flags >> 24 ) & 1;

-   cpucaps.hasStreamingSIMDExtensions                   = ( cpuinfo.x86Flags >> 25 ) & 1; //sse

-   cpucaps.hasStreamingSIMD2Extensions                  = ( cpuinfo.x86Flags >> 26 ) & 1; //sse2

-   cpucaps.hasSelfSnoop                                 = ( cpuinfo.x86Flags >> 27 ) & 1;

-   cpucaps.hasHyperThreading                            = ( cpuinfo.x86Flags >> 28 ) & 1;

-   cpucaps.hasThermalMonitor                            = ( cpuinfo.x86Flags >> 29 ) & 1;

-   cpucaps.hasIntel64BitArchitecture                    = ( cpuinfo.x86Flags >> 30 ) & 1;

-    //that is only for AMDs

-   cpucaps.hasMultimediaExtensionsExt                   = ( cpuinfo.x86EFlags >> 22 ) & 1; //mmx2

-   cpucaps.hasAMD64BitArchitecture                      = ( cpuinfo.x86EFlags >> 29 ) & 1; //64bit cpu

-   cpucaps.has3DNOWInstructionExtensionsExt             = ( cpuinfo.x86EFlags >> 30 ) & 1; //3dnow+

-   cpucaps.has3DNOWInstructionExtensions                = ( cpuinfo.x86EFlags >> 31 ) & 1; //3dnow   

-   cpuinfo.cpuspeed = (u32 )(CPUSpeedHz( 1000 ) / 1000000);

-}

-

-#endif

+/*  Cpudetection lib 
+ *  Copyright (C) 2002-2003  Pcsx2 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
+ */
+
+#ifdef __x86_64__
+
+#if defined (_WIN32)
+#include <windows.h>
+#endif
+
+#include <string.h>
+#include <stdio.h>
+
+#include "ix86-64.h"
+
+#if defined (_MSC_VER) && _MSC_VER >= 1400
+
+   void __cpuid(int* CPUInfo, int InfoType);
+   unsigned __int64 __rdtsc();
+
+   #pragma intrinsic(__cpuid)
+   #pragma intrinsic(__rdtsc)
+
+#endif
+
+CAPABILITIES cpucaps;
+CPUINFO cpuinfo;
+
+#define cpuid(cmd,a,b,c,d) \
+  __asm__ __volatile__("cpuid" \
+		: "=a" (a), "=b" (b), "=c" (c), "=d" (d)  : "0" (cmd))
+
+static s32 iCpuId( u32 cmd, u32 *regs ) 
+{
+   int flag=1;
+
+#if defined (_MSC_VER) && _MSC_VER >= 1400
+
+   __cpuid( regs, cmd );
+
+   return 0;
+
+#elif defined (_MSC_VER) 
+
+#ifdef __x86_64__
+   assert(0);
+#else // __x86_64__
+   __asm 
+   {
+      push ebx;
+      push edi;
+
+      pushfd;
+      pop eax;
+      mov edx, eax;
+      xor eax, 1 << 21;
+      push eax;
+      popfd;
+      pushfd;
+      pop eax;
+      xor eax, edx;
+      mov flag, eax;
+   }
+   if ( ! flag )
+   {
+      return -1;
+   }
+
+   __asm 
+   {
+      mov eax, cmd;
+      cpuid;
+      mov edi, [regs]
+      mov [edi], eax;
+      mov [edi+4], ebx;
+      mov [edi+8], ecx;
+      mov [edi+12], edx;
+
+      pop edi;
+      pop ebx;
+   }
+#endif // __x86_64__
+   return 0;
+
+
+#else
+
+#ifndef __x86_64__
+   // see if we can use cpuid
+   __asm__ __volatile__ (
+      "sub $0x18, %%esp\n"
+      "pushf\n"
+      "pop %%eax\n"
+      "mov %%eax, %%edx\n"
+      "xor $0x200000, %%eax\n"
+      "push %%eax\n"
+      "popf\n"
+      "pushf\n"
+      "pop %%eax\n"
+      "xor %%edx, %%eax\n"
+      "mov %%eax, %0\n"
+	  "add $0x18, %%esp\n"
+      : "=r"(flag) :
+   );
+#endif
+
+   if ( !flag )
+       return -1;
+
+   cpuid(cmd, regs[0], regs[1], regs[2], regs[3]);
+   return 0;
+#endif // _MSC_VER
+}
+
+u64 GetCPUTick( void ) 
+{
+#if defined (_MSC_VER) && _MSC_VER >= 1400
+
+   return __rdtsc();
+
+#elif defined(__MSCW32__) && !defined(__x86_64__)
+
+   __asm rdtsc;
+
+#else
+
+   u32 _a, _d;
+	__asm__ __volatile__ ("rdtsc" : "=a"(_a), "=d"(_d));
+	return (u64)_a | ((u64)_d << 32);
+
+#endif
+}
+
+#if defined(__LINUX__) || defined(__APPLE__)
+
+#include <sys/time.h>
+#include <errno.h>
+//*
+static unsigned long timeGetTime2()
+{
+ struct timeval tv;
+ gettimeofday(&tv, 0);                                 // well, maybe there are better ways
+ return (unsigned long)tv.tv_sec * 1000 + tv.tv_usec/1000;            // to do that, but at least it works
+}
+//*/
+#endif
+
+static s64 CPUSpeedHz( unsigned int time )
+{
+   s64 timeStart, 
+            timeStop;
+   s64 startTick, 
+            endTick;
+   s64 overhead;
+
+   if( ! cpucaps.hasTimeStampCounter )
+   {
+      return 0; //check if function is supported
+   }
+
+	overhead = GetCPUTick() - GetCPUTick();
+	
+	timeStart = timeGetTime2( );
+	while( timeGetTime2( ) == timeStart ) 
+   {
+      timeStart = timeGetTime2( );
+   }
+	for(;;)
+	{
+		timeStop = timeGetTime2( );
+		if ( ( timeStop - timeStart ) > 1 )	
+		{
+			startTick = GetCPUTick( );
+			break;
+		}
+	}
+
+	timeStart = timeStop;
+	for(;;)
+	{
+		timeStop = timeGetTime2( );
+		if ( ( timeStop - timeStart ) > time )	
+		{
+			endTick = GetCPUTick( );
+			break;
+		}
+	}
+
+	return (s64)( ( endTick - startTick ) + ( overhead ) );
+}
+
+////////////////////////////////////////////////////
+void cpudetectInit( void ) 
+{
+   u32 regs[ 4 ];
+   u32 cmds;
+   u32 AMDspeed;
+   char AMDspeedString[10];
+   int cputype=0;            // Cpu type
+   //AMD 64 STUFF
+   u32 x86_64_8BITBRANDID = 0;
+   u32 x86_64_12BITBRANDID = 0;
+   memset( cpuinfo.x86ID, 0, sizeof( cpuinfo.x86ID ) );
+   cpuinfo.x86Family = 0;
+   cpuinfo.x86Model  = 0;
+   cpuinfo.x86PType  = 0;
+   cpuinfo.x86StepID = 0;
+   cpuinfo.x86Flags  = 0;
+   cpuinfo.x86EFlags = 0;
+   
+   if ( iCpuId( 0, regs ) == -1 ) return;
+
+   cmds = regs[ 0 ];
+   ((u32*)cpuinfo.x86ID)[ 0 ] = regs[ 1 ];
+   ((u32*)cpuinfo.x86ID)[ 1 ] = regs[ 3 ];
+   ((u32*)cpuinfo.x86ID)[ 2 ] = regs[ 2 ];
+   if ( cmds >= 0x00000001 ) 
+   {
+      if ( iCpuId( 0x00000001, regs ) != -1 )
+      {
+         cpuinfo.x86StepID =  regs[ 0 ]        & 0xf;
+         cpuinfo.x86Model  = (regs[ 0 ] >>  4) & 0xf;
+         cpuinfo.x86Family = (regs[ 0 ] >>  8) & 0xf;
+         cpuinfo.x86PType  = (regs[ 0 ] >> 12) & 0x3;
+         x86_64_8BITBRANDID = regs[1] & 0xff;
+         cpuinfo.x86Flags  =  regs[ 3 ];
+      }
+   }
+   if ( iCpuId( 0x80000000, regs ) != -1 )
+   {
+      cmds = regs[ 0 ];
+      if ( cmds >= 0x80000001 ) 
+      {
+		 if ( iCpuId( 0x80000001, regs ) != -1 )
+         {
+			x86_64_12BITBRANDID = regs[1] & 0xfff;
+            cpuinfo.x86EFlags = regs[ 3 ];
+            
+         }
+      }
+   }
+   switch(cpuinfo.x86PType)
+   {
+      case 0:
+         strcpy( cpuinfo.x86Type, "Standard OEM");
+         break;
+      case 1:
+         strcpy( cpuinfo.x86Type, "Overdrive");
+         break;
+      case 2:
+         strcpy( cpuinfo.x86Type, "Dual");
+         break;
+      case 3:
+         strcpy( cpuinfo.x86Type, "Reserved");
+         break;
+      default:
+         strcpy( cpuinfo.x86Type, "Unknown");
+         break;
+   }
+   if ( cpuinfo.x86ID[ 0 ] == 'G' ){ cputype=0;}//trick lines but if you know a way better ;p
+   if ( cpuinfo.x86ID[ 0 ] == 'A' ){ cputype=1;}
+   
+   if ( cputype == 0 ) //intel cpu
+   {
+      if( ( cpuinfo.x86Family >= 7 ) && ( cpuinfo.x86Family < 15 ) )
+      {
+         strcpy( cpuinfo.x86Fam, "Intel P6 family (Not PIV and Higher then PPro" );
+      }
+      else
+      {
+         switch( cpuinfo.x86Family )
+         {     
+            // Start at 486 because if it's below 486 there is no cpuid instruction
+            case 4:
+               strcpy( cpuinfo.x86Fam, "Intel 486" );
+               break;
+            case 5:     
+               switch( cpuinfo.x86Model )
+               {
+               case 4:
+               case 8:     // 0.25 �m
+                  strcpy( cpuinfo.x86Fam, "Intel Pentium (MMX)");
+                  break;
+               default:
+                  strcpy( cpuinfo.x86Fam, "Intel Pentium" );
+               }
+               break;
+            case 6:     
+               switch( cpuinfo.x86Model )
+               {
+               case 0:     // Pentium pro (P6 A-Step)
+               case 1:     // Pentium pro
+                  strcpy( cpuinfo.x86Fam, "Intel Pentium Pro" );
+                  break;
+
+               case 2:     // 66 MHz FSB
+               case 5:     // Xeon/Celeron (0.25 �m)
+               case 6:     // Internal L2 cache
+                  strcpy( cpuinfo.x86Fam, "Intel Pentium II" );
+                  break;
+
+               case 7:     // Xeon external L2 cache
+               case 8:     // Xeon/Celeron with 256 KB on-die L2 cache
+               case 10:    // Xeon/Celeron with 1 or 2 MB on-die L2 cache
+               case 11:    // Xeon/Celeron with Tualatin core, on-die cache
+                  strcpy( cpuinfo.x86Fam, "Intel Pentium III" );
+                  break;
+			   case 15:    // Core 2 Duo Allendale/Conroe
+				  strcpy( cpuinfo.x86Fam, "Intel Core 2 Duo" );
+				  break;
+
+               default:
+                  strcpy( cpuinfo.x86Fam, "Intel Pentium Pro (Unknown)" );
+               }
+               break;
+            case 15:
+               switch( cpuinfo.x86Model )
+               {
+               case 0:     // Willamette (A-Step)
+               case 1:     // Willamette 
+                  strcpy( cpuinfo.x86Fam, "Willamette Intel Pentium IV" );
+                  break;
+               case 2:     // Northwood 
+                  strcpy( cpuinfo.x86Fam, "Northwood Intel Pentium IV" );
+                  break;
+
+               default:
+                  strcpy( cpuinfo.x86Fam, "Intel Pentium IV (Unknown)" );
+                  break;
+               }
+               break;
+            default:
+               strcpy( cpuinfo.x86Fam, "Unknown Intel CPU" );
+         }
+      }
+   }
+   else if ( cputype == 1 ) //AMD cpu
+   {
+      if( cpuinfo.x86Family >= 7 )
+      {
+		  if((x86_64_12BITBRANDID !=0) || (x86_64_8BITBRANDID !=0))
+		  {
+		    if(x86_64_8BITBRANDID == 0 )
+		    {
+               switch((x86_64_12BITBRANDID >>6)& 0x3f)
+			   {
+			    case 4:
+				 strcpy(cpuinfo.x86Fam,"AMD Athlon(tm) 64 Processor");
+                 AMDspeed = 22 + (x86_64_12BITBRANDID & 0x1f);
+				 //AMDspeedString = strtol(AMDspeed, (char**)NULL,10);
+				 sprintf(AMDspeedString," %d",AMDspeed);
+				 strcat(AMDspeedString,"00+");
+				 strcat(cpuinfo.x86Fam,AMDspeedString);
+				 break;
+			    case 12: 
+				 strcpy(cpuinfo.x86Fam,"AMD Opteron(tm) Processor");
+				 break;
+			    case 5:
+				  strcpy( cpuinfo.x86Fam, "AMD Athlon X2 Processor" );
+				  AMDspeed = 22 + (x86_64_12BITBRANDID & 0x1f);
+				 //AMDspeedString = strtol(AMDspeed, (char**)NULL,10);
+				 sprintf(AMDspeedString," %d",AMDspeed);
+				 strcat(AMDspeedString,"00+");
+				 strcat(cpuinfo.x86Fam,AMDspeedString);
+                  break;
+			   case 44:
+				   strcpy( cpuinfo.x86Fam, "AMD Opteron(tm) Dual Core Processor" );
+                  break;
+			    default:
+				   strcpy(cpuinfo.x86Fam,"Unknown AMD 64 proccesor");
+				   
+			    }
+		     }
+		     else //8bit brand id is non zero
+		     {
+                strcpy(cpuinfo.x86Fam,"Unsupported yet AMD64 cpu");
+		     }
+		  }
+		  else
+		  {		 
+			  strcpy( cpuinfo.x86Fam, "AMD K7+ Processor" );
+		  }
+      }
+      else
+      {
+         switch ( cpuinfo.x86Family )
+         {
+            case 4:
+               switch( cpuinfo.x86Model )
+               {
+               case 14: 
+               case 15:       // Write-back enhanced
+                  strcpy( cpuinfo.x86Fam, "AMD 5x86 Processor" );
+                  break;
+
+               case 3:        // DX2
+               case 7:        // Write-back enhanced DX2
+               case 8:        // DX4
+               case 9:        // Write-back enhanced DX4
+                  strcpy( cpuinfo.x86Fam, "AMD 486 Processor" );
+                  break;
+			   			   
+
+               default:
+                  strcpy( cpuinfo.x86Fam, "AMD Unknown Processor" );
+
+               }
+               break;
+
+            case 5:     
+               switch( cpuinfo.x86Model)
+               {
+               case 0:     // SSA 5 (75, 90 and 100 Mhz)
+               case 1:     // 5k86 (PR 120 and 133 MHz)
+               case 2:     // 5k86 (PR 166 MHz)
+               case 3:     // K5 5k86 (PR 200 MHz)
+                  strcpy( cpuinfo.x86Fam, "AMD K5 Processor" );
+                  break;
+
+               case 6:     
+               case 7:     // (0.25 �m)
+               case 8:     // K6-2
+               case 9:     // K6-III
+               case 14:    // K6-2+ / K6-III+
+                  strcpy( cpuinfo.x86Fam, "AMD K6 Series Processor" );
+                  break;
+
+               default:
+                  strcpy( cpuinfo.x86Fam, "AMD Unknown Processor" );
+               }
+               break;
+            case 6:     
+               strcpy( cpuinfo.x86Fam, "AMD Athlon XP Processor" );
+               break;
+            default:
+               strcpy( cpuinfo.x86Fam, "Unknown AMD CPU" ); 
+         }
+      }
+   }
+   //capabilities
+   cpucaps.hasFloatingPointUnit                         = ( cpuinfo.x86Flags >>  0 ) & 1;
+   cpucaps.hasVirtual8086ModeEnhancements               = ( cpuinfo.x86Flags >>  1 ) & 1;
+   cpucaps.hasDebuggingExtensions                       = ( cpuinfo.x86Flags >>  2 ) & 1;
+   cpucaps.hasPageSizeExtensions                        = ( cpuinfo.x86Flags >>  3 ) & 1;
+   cpucaps.hasTimeStampCounter                          = ( cpuinfo.x86Flags >>  4 ) & 1;
+   cpucaps.hasModelSpecificRegisters                    = ( cpuinfo.x86Flags >>  5 ) & 1;
+   cpucaps.hasPhysicalAddressExtension                  = ( cpuinfo.x86Flags >>  6 ) & 1;
+   cpucaps.hasMachineCheckArchitecture                  = ( cpuinfo.x86Flags >>  7 ) & 1;
+   cpucaps.hasCOMPXCHG8BInstruction                     = ( cpuinfo.x86Flags >>  8 ) & 1;
+   cpucaps.hasAdvancedProgrammableInterruptController   = ( cpuinfo.x86Flags >>  9 ) & 1;
+   cpucaps.hasSEPFastSystemCall                         = ( cpuinfo.x86Flags >> 11 ) & 1;
+   cpucaps.hasMemoryTypeRangeRegisters                  = ( cpuinfo.x86Flags >> 12 ) & 1;
+   cpucaps.hasPTEGlobalFlag                             = ( cpuinfo.x86Flags >> 13 ) & 1;
+   cpucaps.hasMachineCheckArchitecture                  = ( cpuinfo.x86Flags >> 14 ) & 1;
+   cpucaps.hasConditionalMoveAndCompareInstructions     = ( cpuinfo.x86Flags >> 15 ) & 1;
+   cpucaps.hasFGPageAttributeTable                      = ( cpuinfo.x86Flags >> 16 ) & 1;
+   cpucaps.has36bitPageSizeExtension                    = ( cpuinfo.x86Flags >> 17 ) & 1;
+   cpucaps.hasProcessorSerialNumber                     = ( cpuinfo.x86Flags >> 18 ) & 1;
+   cpucaps.hasCFLUSHInstruction                         = ( cpuinfo.x86Flags >> 19 ) & 1;
+   cpucaps.hasDebugStore                                = ( cpuinfo.x86Flags >> 21 ) & 1;
+   cpucaps.hasACPIThermalMonitorAndClockControl         = ( cpuinfo.x86Flags >> 22 ) & 1;
+   cpucaps.hasMultimediaExtensions                      = ( cpuinfo.x86Flags >> 23 ) & 1; //mmx
+   cpucaps.hasFastStreamingSIMDExtensionsSaveRestore    = ( cpuinfo.x86Flags >> 24 ) & 1;
+   cpucaps.hasStreamingSIMDExtensions                   = ( cpuinfo.x86Flags >> 25 ) & 1; //sse
+   cpucaps.hasStreamingSIMD2Extensions                  = ( cpuinfo.x86Flags >> 26 ) & 1; //sse2
+   cpucaps.hasSelfSnoop                                 = ( cpuinfo.x86Flags >> 27 ) & 1;
+   cpucaps.hasHyperThreading                            = ( cpuinfo.x86Flags >> 28 ) & 1;
+   cpucaps.hasThermalMonitor                            = ( cpuinfo.x86Flags >> 29 ) & 1;
+   cpucaps.hasIntel64BitArchitecture                    = ( cpuinfo.x86Flags >> 30 ) & 1;
+    //that is only for AMDs
+   cpucaps.hasMultimediaExtensionsExt                   = ( cpuinfo.x86EFlags >> 22 ) & 1; //mmx2
+   cpucaps.hasAMD64BitArchitecture                      = ( cpuinfo.x86EFlags >> 29 ) & 1; //64bit cpu
+   cpucaps.has3DNOWInstructionExtensionsExt             = ( cpuinfo.x86EFlags >> 30 ) & 1; //3dnow+
+   cpucaps.has3DNOWInstructionExtensions                = ( cpuinfo.x86EFlags >> 31 ) & 1; //3dnow   
+   cpuinfo.cpuspeed = (u32 )(CPUSpeedHz( 1000 ) / 1000000);
+}
+
+#endif
diff --git a/libpcsxcore/ix86_64/ix86_mmx.c b/libpcsxcore/ix86_64/ix86_mmx.c
index 09784a9c..4df678f0 100644
--- a/libpcsxcore/ix86_64/ix86_mmx.c
+++ b/libpcsxcore/ix86_64/ix86_mmx.c
@@ -1,6 +1,7 @@
 // stop compiling if NORECBUILD build (only for Visual Studio)
 
-#ifdef __x86_64__
+/* note that ix86-64.h disables all MMX, so no point in compiling this, ever */
+#ifndef __x86_64__
 
 #if !(defined(_MSC_VER) && defined(PCSX2_NORECBUILD))
 
diff --git a/libpcsxcore/ix86_64/ix86_sse.c b/libpcsxcore/ix86_64/ix86_sse.c
index 8a4f0217..09907043 100644
--- a/libpcsxcore/ix86_64/ix86_sse.c
+++ b/libpcsxcore/ix86_64/ix86_sse.c
@@ -89,9 +89,6 @@ XMMSSEType g_xmmtypes[XMMREGS] = {0};
 
 
 
-void WriteRmOffset(x86IntRegType to, int offset);
-void WriteRmOffsetFrom(x86IntRegType to, x86IntRegType from, int offset);
-
 /* movups [r32][r32*scale] to xmm1 */
 void SSE_MOVUPSRmStoR( x86SSERegType to, x86IntRegType from, x86IntRegType from2, int scale )
 {
@@ -1326,24 +1323,6 @@ void SSE2EMU_MOVD_XMM_to_RmOffset(x86IntRegType to, x86SSERegType from, int offs
 	MOV32RtoRmOffset(to, EAX, offset);
 }
 
-#ifndef __x86_64__
-extern void SetMMXstate();
-
-void SSE2EMU_MOVDQ2Q_XMM_to_MM( x86MMXRegType to, x86SSERegType from)
-{
-	SSE_MOVLPS_XMM_to_M64(p, from);
-	MOVQMtoR(to, p);
-	SetMMXstate();
-}
-
-void SSE2EMU_MOVQ2DQ_MM_to_XMM( x86SSERegType to, x86MMXRegType from)
-{
-	MOVQRtoM(p, from);
-	SSE_MOVLPS_M64_to_XMM(to, p);
-	SetMMXstate();
-}
-#endif
-
 /****************************************************************************/
 /*  SSE2 Emulated functions for SSE CPU's by kekko							*/
 /****************************************************************************/
@@ -1398,16 +1377,7 @@ void SSE2EMU_MOVD_XMM_to_R( x86IntRegType to, x86SSERegType from ) {
 	MOV32RmtoR(to, to);
 }
 
-#ifndef __x86_64__
-extern void SetFPUstate();
-extern void _freeMMXreg(int mmxreg);
-#endif
-
 void SSE2EMU_CVTPS2DQ_XMM_to_XMM( x86SSERegType to, x86SSERegType from ) {
-#ifndef __x86_64__
-    SetFPUstate();
-	_freeMMXreg(7);
-#endif
 	SSE_MOVAPS_XMM_to_M128((uptr)f, from);
 	
 	FLD32((uptr)&f[0]);
@@ -1423,10 +1393,6 @@ void SSE2EMU_CVTPS2DQ_XMM_to_XMM( x86SSERegType to, x86SSERegType from ) {
 }
 
 void SSE2EMU_CVTDQ2PS_M128_to_XMM( x86SSERegType to, uptr from ) {
-#ifndef __x86_64__
-    SetFPUstate();
-	_freeMMXreg(7);
-#endif
 	FILD32(from);
 	FSTP32((uptr)&f[0]);
 	FILD32(from+4);
diff --git a/libpcsxcore/mdec.c b/libpcsxcore/mdec.c
index 303bd679..b25b9612 100644
--- a/libpcsxcore/mdec.c
+++ b/libpcsxcore/mdec.c
@@ -19,7 +19,7 @@
  ***************************************************************************/
 
 #include "mdec.h"
-

+
 /* memory speed is 1 byte per MDEC_BIAS psx clock
  * That mean (PSXCLK / MDEC_BIAS) B/s
  * MDEC_BIAS = 2.0 => ~16MB/s
@@ -31,8 +31,8 @@
  * 320x240x16@50Hz => 7.68 MB/s
  * 320x240x16@60Hz => 9.216 MB/s
  * so 2.0 to 4.0 should be fine.
- */

-#define MDEC_BIAS 2.0f

+ */
+#define MDEC_BIAS 2.0f
 
 #define DSIZE			8
 #define DSIZE2			(DSIZE * DSIZE)
@@ -80,7 +80,7 @@ static inline void fillrow(int *blk, int val) {
 		= blk[4] = blk[5] = blk[6] = blk[7] = val;
 }
 
-void idct(int *block,int used_col) {
+static void idct(int *block,int used_col) {
 	int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 	int z5, z10, z11, z12, z13;
 	int *ptr;
@@ -263,7 +263,7 @@ static void iqtab_init(int *iqtab, unsigned char *iq_y) {
 
 #define	MDEC_END_OF_DATA	0xfe00
 
-unsigned short *rl2blk(int *blk, unsigned short *mdec_rl) {
+static unsigned short *rl2blk(int *blk, unsigned short *mdec_rl) {
 	int i, k, q_scale, rl, used_col;
  	int *iqtab;
 
@@ -324,7 +324,7 @@ unsigned short *rl2blk(int *blk, unsigned short *mdec_rl) {
 #define CLAMP_SCALE8(a)   (CLAMP8(SCALE8(a)))
 #define CLAMP_SCALE5(a)   (CLAMP5(SCALE5(a)))
 
-inline void putlinebw15(u16 *image, int *Yblk) {
+static inline void putlinebw15(u16 *image, int *Yblk) {
 	int i;
 	int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;
 
@@ -335,7 +335,7 @@ inline void putlinebw15(u16 *image, int *Yblk) {
 	}
 }
 
-inline void putquadrgb15(u16 *image, int *Yblk, int Cr, int Cb) {
+static inline void putquadrgb15(u16 *image, int *Yblk, int Cr, int Cb) {
 	int Y, R, G, B;
 	int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;
 	R = MULR(Cr);
@@ -353,7 +353,7 @@ inline void putquadrgb15(u16 *image, int *Yblk, int Cr, int Cb) {
 	image[17] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
 }
 
-inline void yuv2rgb15(int *blk, unsigned short *image) {
+static inline void yuv2rgb15(int *blk, unsigned short *image) {
 	int x, y;
 	int *Yblk = blk + DSIZE2 * 2;
 	int *Crblk = blk;
@@ -376,7 +376,7 @@ inline void yuv2rgb15(int *blk, unsigned short *image) {
 	}
 }
 
-inline void putlinebw24(u8 * image, int *Yblk) {
+static inline void putlinebw24(u8 * image, int *Yblk) {
 	int i;
 	unsigned char Y;
 	for (i = 0; i < 8 * 3; i += 3, Yblk++) {
@@ -387,7 +387,7 @@ inline void putlinebw24(u8 * image, int *Yblk) {
 	}
 }
 
-inline void putquadrgb24(u8 * image, int *Yblk, int Cr, int Cb) {
+static inline void putquadrgb24(u8 * image, int *Yblk, int Cr, int Cb) {
 	int Y, R, G, B;
 
 	R = MULR(Cr);
@@ -545,7 +545,7 @@ void psxDma1(u32 adr, u32 bcr, u32 chcr) {
 	int dmacnt;
 
 	if (chcr != 0x01000200) return;
-

+
 	size = (bcr >> 16) * (bcr & 0xffff);
 	/* size in byte */
 	size *= 4;
@@ -558,7 +558,7 @@ void psxDma1(u32 adr, u32 bcr, u32 chcr) {
 		mdec.pending_dma1.bcr = bcr;
 		mdec.pending_dma1.chcr = chcr;
 		/* do not free the dma */
-	} else {

+	} else {
 
 	image = (u8 *)PSXM(adr);
 
@@ -619,9 +619,9 @@ void psxDma1(u32 adr, u32 bcr, u32 chcr) {
 			memcpy(image, mdec.block_buffer, size);
 			mdec.block_buffer_pos = mdec.block_buffer + size;
 		}
-	}

+	}
 	
-	/* define the power of mdec */

+	/* define the power of mdec */
 	MDECOUTDMA_INT((int) ((dmacnt* MDEC_BIAS)));
 	}
 }
diff --git a/libpcsxcore/misc.c b/libpcsxcore/misc.c
index 3f47e083..533dfd71 100644
--- a/libpcsxcore/misc.c
+++ b/libpcsxcore/misc.c
@@ -51,7 +51,7 @@ struct iso_directory_record {
 	char name			[1];
 };
 
-void mmssdd( char *b, char *p )
+static void mmssdd( char *b, char *p )
 {
 	int m, s, d;
 #if defined(__BIGENDIAN__)
@@ -101,9 +101,9 @@ void mmssdd( char *b, char *p )
 	READTRACK(); \
 	memcpy(_dir + 2048, buf + 12, 2048);
 
-int GetCdromFile(u8 *mdir, u8 *time, s8 *filename) {
+static int GetCdromFile(u8 *mdir, u8 *time, char *filename) {
 	struct iso_directory_record *dir;
-	char ddir[4096];
+	u8 ddir[4096];
 	u8 *buf;
 	int i;
 
@@ -144,7 +144,7 @@ int LoadCdrom() {
 	struct iso_directory_record *dir;
 	u8 time[4], *buf;
 	u8 mdir[4096];
-	s8 exename[256];
+	char exename[256];
 
 	if (!Config.HLE) {
 		if (!Config.SlowBoot) psxRegs.pc = psxRegs.GPR.n.ra;
@@ -177,7 +177,7 @@ int LoadCdrom() {
 		if (GetCdromFile(mdir, time, exename) == -1) {
 			sscanf((char *)buf + 12, "BOOT = cdrom:%256s", exename);
 			if (GetCdromFile(mdir, time, exename) == -1) {
-				char *ptr = strstr(buf + 12, "cdrom:");
+				char *ptr = strstr((char *)buf + 12, "cdrom:");
 				if (ptr != NULL) {
 					ptr += 6;
 					while (*ptr == '\\' || *ptr == '/') ptr++;
@@ -226,7 +226,8 @@ int LoadCdrom() {
 int LoadCdromFile(const char *filename, EXE_HEADER *head) {
 	struct iso_directory_record *dir;
 	u8 time[4],*buf;
-	u8 mdir[4096], exename[256];
+	u8 mdir[4096];
+	char exename[256];
 	u32 size, addr;
 
 	sscanf(filename, "cdrom:\\%256s", exename);
@@ -281,7 +282,7 @@ int CheckCdrom() {
 	CdromLabel[0] = '\0';
 	CdromId[0] = '\0';
 
-	strncpy(CdromLabel, buf + 52, 32);
+	strncpy(CdromLabel, (char *)buf + 52, 32);
 
 	// skip head and sub, and go to the root directory record
 	dir = (struct iso_directory_record *)&buf[12 + 156]; 
@@ -297,7 +298,7 @@ int CheckCdrom() {
 		if (GetCdromFile(mdir, time, exename) == -1) {
 			sscanf((char *)buf + 12, "BOOT = cdrom:%256s", exename);
 			if (GetCdromFile(mdir, time, exename) == -1) {
-				char *ptr = strstr(buf + 12, "cdrom:");			// possibly the executable is in some subdir
+				char *ptr = strstr((char *)buf + 12, "cdrom:");			// possibly the executable is in some subdir
 				if (ptr != NULL) {
 					ptr += 6;
 					while (*ptr == '\\' || *ptr == '/') ptr++;
@@ -359,7 +360,8 @@ static int PSXGetFileType(FILE *f) {
 
 	current = ftell(f);
 	fseek(f, 0L, SEEK_SET);
-	fread(mybuf, 2048, 1, f);
+	if(fread(mybuf, 2048, 1, f) != 1)
+		return INVALID_EXE;
 	fseek(f, current, SEEK_SET);
 
 	exe_hdr = (EXE_HEADER *)mybuf;
@@ -386,7 +388,8 @@ static void LoadLibPS() {
 
 	if (f != NULL) {
 		fseek(f, 0x800, SEEK_SET);
-		fread(psxM + 0x10000, 0x61000, 1, f);
+		if(fread(psxM + 0x10000, 0x61000, 1, f) != 1)
+			perror(buf);
 		fclose(f);
 	}
 }
@@ -415,10 +418,14 @@ int Load(const char *ExePath) {
 		type = PSXGetFileType(tmpFile);
 		switch (type) {
 			case PSX_EXE:
-				fread(&tmpHead, sizeof(EXE_HEADER), 1, tmpFile);
-				fseek(tmpFile, 0x800, SEEK_SET);		
-				fread(PSXM(SWAP32(tmpHead.t_addr)), SWAP32(tmpHead.t_size), 1, tmpFile);
+				if(fread(&tmpHead, sizeof(EXE_HEADER), 1, tmpFile) != 1 ||
+				   fseek(tmpFile, 0x800, SEEK_SET) < 0 ||
+				   fread(PSXM(SWAP32(tmpHead.t_addr)), SWAP32(tmpHead.t_size), 1, tmpFile) != 1) {
+					retval = -1;
+					perror(ExePath);
+				}
 				fclose(tmpFile);
+				if(retval == -1) break;
 				psxRegs.pc = SWAP32(tmpHead.pc0);
 				psxRegs.GPR.n.gp = SWAP32(tmpHead.gp0);
 				psxRegs.GPR.n.sp = SWAP32(tmpHead.s_addr); 
@@ -430,21 +437,36 @@ int Load(const char *ExePath) {
 			case CPE_EXE:
 				fseek(tmpFile, 6, SEEK_SET); /* Something tells me we should go to 4 and read the "08 00" here... */
 				do {
-					fread(&opcode, 1, 1, tmpFile);
+					if(fread(&opcode, 1, 1, tmpFile) != 1) {
+						perror(ExePath);
+						retval = -1;
+						break;
+					}
 					switch (opcode) {
 						case 1: /* Section loading */
-							fread(&section_address, 4, 1, tmpFile);
-							fread(&section_size, 4, 1, tmpFile);
+							if(fread(&section_address, 4, 1, tmpFile) != 1 ||
+							   fread(&section_size, 4, 1, tmpFile) != 1) {
+								retval = -1;
+								perror(ExePath);
+								break;
+							}
 							section_address = SWAPu32(section_address);
 							section_size = SWAPu32(section_size);
 #ifdef EMU_LOG
 							EMU_LOG("Loading %08X bytes from %08X to %08X\n", section_size, ftell(tmpFile), section_address);
 #endif
-							fread(PSXM(section_address), section_size, 1, tmpFile);
+							if(fread(PSXM(section_address), section_size, 1, tmpFile) != 1) {
+								retval = -1;
+								perror(ExePath);
+							}
 							break;
 						case 3: /* register loading (PC only?) */
-							fseek(tmpFile, 2, SEEK_CUR); /* unknown field */
-							fread(&psxRegs.pc, 4, 1, tmpFile);
+							if(fseek(tmpFile, 2, SEEK_CUR) < 0 || /* unknown field */
+							   fread(&psxRegs.pc, 4, 1, tmpFile) != 1) {
+								retval = -1;
+								perror(ExePath);
+								break;
+							}
 							psxRegs.pc = SWAPu32(psxRegs.pc);
 							break;
 						case 0: /* End of file */
@@ -458,19 +480,31 @@ int Load(const char *ExePath) {
 				break;
 
 			case COFF_EXE:
-				fread(&coffHead, sizeof(coffHead), 1, tmpFile);
-				fread(&optHead, sizeof(optHead), 1, tmpFile);
+				if(fread(&coffHead, sizeof(coffHead), 1, tmpFile) != 1 ||
+				   fread(&optHead, sizeof(optHead), 1, tmpFile) != 1) {
+					retval = -1;
+					perror(ExePath);
+					break;
+				}
 
 				psxRegs.pc = SWAP32(optHead.entry);
 				psxRegs.GPR.n.sp = 0x801fff00;
 
 				for (i = 0; i < SWAP16(coffHead.f_nscns); i++) {
-					fseek(tmpFile, sizeof(FILHDR) + SWAP16(coffHead.f_opthdr) + sizeof(section) * i, SEEK_SET);
-					fread(&section, sizeof(section), 1, tmpFile);
+					if(fseek(tmpFile, sizeof(FILHDR) + SWAP16(coffHead.f_opthdr) + sizeof(section) * i, SEEK_SET) < 0 ||
+					   fread(&section, sizeof(section), 1, tmpFile) != 1) {
+						retval = -1;
+						perror(ExePath);
+						break;
+					}
 
 					if (section.s_scnptr != 0) {
-						fseek(tmpFile, SWAP32(section.s_scnptr), SEEK_SET);
-						fread(PSXM(SWAP32(section.s_paddr)), SWAP32(section.s_size), 1, tmpFile);
+						if(fseek(tmpFile, SWAP32(section.s_scnptr), SEEK_SET) < 0 ||
+						   fread(PSXM(SWAP32(section.s_paddr)), SWAP32(section.s_size), 1, tmpFile) != 1) {
+							retval = -1;
+							perror(ExePath);
+							break;
+						}
 					} else {
 						memset(PSXM(SWAP32(section.s_paddr)), 0, SWAP32(section.s_size));
 					}
diff --git a/libpcsxcore/plugin_common.h b/libpcsxcore/plugin_common.h
new file mode 100644
index 00000000..7e12d59e
--- /dev/null
+++ b/libpcsxcore/plugin_common.h
@@ -0,0 +1,99 @@
+/***************************************************************************
+ *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, 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.           *
+ ***************************************************************************/
+
+#ifndef __PLUGIN_COMMON_H__
+#define __PLUGIN_COMMON_H__
+
+//#define ENABLE_SIO1API 1
+
+#ifndef _WIN32
+
+typedef void* HWND;
+#define CALLBACK
+
+#else
+
+#include <windows.h>
+
+#endif
+
+#include "decode_xa.h"
+
+typedef struct {
+	uint32_t ulFreezeVersion;
+	uint32_t ulStatus;
+	uint32_t ulControl[256];
+	unsigned char psxVRam[1024*1024*2];
+} GPUFreeze_t;
+
+#ifdef Status /* defined by X11 includes */
+#undef Status
+#endif
+
+struct CdrStat {
+	uint32_t Type;
+	uint32_t Status;
+	unsigned char Time[3];
+};
+
+struct SubQ {
+	char res0[12];
+	unsigned char ControlAndADR;
+	unsigned char TrackNumber;
+	unsigned char IndexNumber;
+	unsigned char TrackRelativeAddress[3];
+	unsigned char Filler;
+	unsigned char AbsoluteAddress[3];
+	unsigned char CRC[2];
+	char res1[72];
+};
+
+typedef struct {
+	char PluginName[8];
+	uint32_t PluginVersion;
+	uint32_t Size;
+	unsigned char SPUPorts[0x200];
+	unsigned char SPURam[0x80000];
+	xa_decode_t xa;
+	unsigned char *SPUInfo;
+} SPUFreeze_t;
+
+typedef long (CALLBACK* GPUshowScreenPicCB)(unsigned char *);
+typedef void (CALLBACK* GPUdisplayTextCB)(char *);
+typedef void (CALLBACK* PADsetSensitiveCB)(int);
+
+typedef struct {
+	char EmuName[32];
+	char CdromID[9];	// ie. 'SCPH12345', no \0 trailing character
+	char CdromLabel[11];
+	void *psxMem;
+	GPUshowScreenPicCB GPU_showScreenPic;
+	GPUdisplayTextCB GPU_displayText;
+	PADsetSensitiveCB PAD_setSensitive;
+	char GPUpath[256];	// paths must be absolute
+	char SPUpath[256];
+	char CDRpath[256];
+	char MCD1path[256];
+	char MCD2path[256];
+	char BIOSpath[256];	// 'HLE' for internal bios
+	char Unused[1024];
+} netInfo;
+
+
+#endif
diff --git a/libpcsxcore/plugins.c b/libpcsxcore/plugins.c
index dca6e7b6..009bf2dd 100644
--- a/libpcsxcore/plugins.c
+++ b/libpcsxcore/plugins.c
@@ -1,849 +1,852 @@
-/***************************************************************************

- *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, 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.           *

- ***************************************************************************/

-

-/*

-* Plugin library callback/access functions.

-*/

-

-#include "plugins.h"

-#include "cdriso.h"

-

-static char IsoFile[MAXPATHLEN] = "";

-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;

-GPUreadData           GPU_readData;

-GPUreadDataMem        GPU_readDataMem;

-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;

-GPUclearDynarec       GPU_clearDynarec;

-GPUvBlank             GPU_vBlank;

-GPUregisterCallback   GPU_registerCallback;

-GPUidle               GPU_idle;

-GPUvisualVibration    GPU_visualVibration;

-GPUcursor             GPU_cursor;

-

-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;

-

-SPUconfigure          SPU_configure;

-SPUabout              SPU_about;

-SPUinit               SPU_init;

-SPUshutdown           SPU_shutdown;

-SPUtest               SPU_test;

-SPUopen               SPU_open;

-SPUclose              SPU_close;

-SPUplaySample         SPU_playSample;

-SPUwriteRegister      SPU_writeRegister;

-SPUreadRegister       SPU_readRegister;

-SPUwriteDMA           SPU_writeDMA;

-SPUreadDMA            SPU_readDMA;

-SPUwriteDMAMem        SPU_writeDMAMem;

-SPUreadDMAMem         SPU_readDMAMem;

-SPUplayADPCMchannel   SPU_playADPCMchannel;

-SPUfreeze             SPU_freeze;

-SPUregisterCallback   SPU_registerCallback;

-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;

-PADregisterVibration  PAD1_registerVibration;

-PADregisterCursor     PAD1_registerCursor;

-

-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;

-PADregisterVibration  PAD2_registerVibration;

-PADregisterCursor     PAD2_registerCursor;

-

-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;

-

-#ifdef ENABLE_SIO1API

-

-SIO1init              SIO1_init;

-SIO1shutdown          SIO1_shutdown;

-SIO1open              SIO1_open;

-SIO1close             SIO1_close;

-SIO1test              SIO1_test;

-SIO1configure         SIO1_configure;

-SIO1about             SIO1_about;

-SIO1pause             SIO1_pause;

-SIO1resume            SIO1_resume;

-SIO1keypressed        SIO1_keypressed;

-SIO1writeData8        SIO1_writeData8;

-SIO1writeData16       SIO1_writeData16;

-SIO1writeData32       SIO1_writeData32;

-SIO1writeStat16       SIO1_writeStat16;

-SIO1writeStat32       SIO1_writeStat32;

-SIO1writeMode16       SIO1_writeMode16;

-SIO1writeMode32       SIO1_writeMode32;

-SIO1writeCtrl16       SIO1_writeCtrl16;

-SIO1writeCtrl32       SIO1_writeCtrl32;

-SIO1writeBaud16       SIO1_writeBaud16;

-SIO1writeBaud32       SIO1_writeBaud32;

-SIO1readData8         SIO1_readData8;

-SIO1readData16        SIO1_readData16;

-SIO1readData32        SIO1_readData32;

-SIO1readStat16        SIO1_readStat16;

-SIO1readStat32        SIO1_readStat32;

-SIO1readMode16        SIO1_readMode16;

-SIO1readMode32        SIO1_readMode32;

-SIO1readCtrl16        SIO1_readCtrl16;

-SIO1readCtrl32        SIO1_readCtrl32;

-SIO1readBaud16        SIO1_readBaud16;

-SIO1readBaud32        SIO1_readBaud32;

-SIO1registerCallback  SIO1_registerCallback;

-

-#endif

-

-static const char *err;

-

-#define CheckErr(func) { \

-	err = SysLibError(); \

-	if (err != NULL) { SysMessage(_("Error loading %s: %s"), func, err); return -1; } \

-}

-

-#define LoadSym(dest, src, name, checkerr) { \

-	dest = (src)SysLoadSym(drv, name); \

-	if (checkerr) { CheckErr(name); } else SysLibError(); \

-}

-

-void *hGPUDriver = NULL;

-

-void CALLBACK GPU__displayText(char *pText) {

-	SysPrintf("%s\n", pText);

-}

-

-void CALLBACK GPUbusy( int ticks )

-{

-    //printf( "GPUbusy( %i )\n", ticks );

-    //fflush( 0 );

-

-    psxRegs.interrupt |= (1 << PSXINT_GPUBUSY);

-    psxRegs.intCycle[PSXINT_GPUBUSY].cycle = ticks;

-    psxRegs.intCycle[PSXINT_GPUBUSY].sCycle = psxRegs.cycle;

-}

-

-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__clearDynarec(void (CALLBACK *callback)(void)) {}

-void CALLBACK GPU__vBlank(int val) {}

-void CALLBACK GPU__registerCallback(void (CALLBACK *callback)(int)) {}

-void CALLBACK GPU__idle(void) {}

-void CALLBACK GPU__visualVibration(unsigned long iSmall, unsigned long iBig) {}

-void CALLBACK GPU__cursor(int player, int x, int y) {}

-

-#define LoadGpuSym1(dest, name) \

-	LoadSym(GPU_##dest, GPU##dest, name, TRUE);

-

-#define LoadGpuSym0(dest, name) \

-	LoadSym(GPU_##dest, GPU##dest, name, FALSE); \

-	if (GPU_##dest == NULL) GPU_##dest = (GPU##dest) GPU__##dest;

-

-#define LoadGpuSymN(dest, name) \

-	LoadSym(GPU_##dest, GPU##dest, name, FALSE);

-

-static int LoadGPUplugin(const char *GPUdll) {

-	void *drv;

-

-	hGPUDriver = SysLoadLibrary(GPUdll);

-	if (hGPUDriver == NULL) {

-		GPU_configure = NULL;

-		SysMessage (_("Could not load GPU plugin %s!"), GPUdll); return -1;

-	}

-	drv = hGPUDriver;

-	LoadGpuSym1(init, "GPUinit");

-	LoadGpuSym1(shutdown, "GPUshutdown");

-	LoadGpuSym1(open, "GPUopen");

-	LoadGpuSym1(close, "GPUclose");

-	LoadGpuSym1(readData, "GPUreadData");

-	LoadGpuSym1(readDataMem, "GPUreadDataMem");

-	LoadGpuSym1(readStatus, "GPUreadStatus");

-	LoadGpuSym1(writeData, "GPUwriteData");

-	LoadGpuSym1(writeDataMem, "GPUwriteDataMem");

-	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(clearDynarec, "GPUclearDynarec");

-    LoadGpuSym0(vBlank, "GPUvBlank");

-    LoadGpuSym0(registerCallback, "GPUregisterCallback");

-    LoadGpuSym0(idle, "GPUidle");

-    LoadGpuSym0(visualVibration, "GPUvisualVibration");

-    LoadGpuSym0(cursor, "GPUcursor");

-	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) {

-	if (cdOpenCaseTime < 0 || cdOpenCaseTime > (s64)time(NULL))

-		stat->Status = 0x10;

-	else

-		stat->Status = 0;

-

-	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;

-}

-

-void *hSPUDriver = NULL;

-

-long CALLBACK SPU__configure(void) { return 0; }

-void CALLBACK SPU__about(void) {}

-long CALLBACK SPU__test(void) { return 0; }

-

-#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;

-

-#define LoadSpuSymN(dest, name) \

-	LoadSym(SPU_##dest, SPU##dest, name, FALSE);

-

-static int LoadSPUplugin(const char *SPUdll) {

-	void *drv;

-

-	hSPUDriver = SysLoadLibrary(SPUdll);

-	if (hSPUDriver == NULL) {

-		SPU_configure = NULL;

-		SysMessage (_("Could not load SPU plugin %s!"), SPUdll); return -1;

-	}

-	drv = hSPUDriver;

-	LoadSpuSym1(init, "SPUinit");

-	LoadSpuSym1(shutdown, "SPUshutdown");

-	LoadSpuSym1(open, "SPUopen");

-	LoadSpuSym1(close, "SPUclose");

-	LoadSpuSym0(configure, "SPUconfigure");

-	LoadSpuSym0(about, "SPUabout");

-	LoadSpuSym0(test, "SPUtest");

-	LoadSpuSym1(writeRegister, "SPUwriteRegister");

-	LoadSpuSym1(readRegister, "SPUreadRegister");

-	LoadSpuSym1(writeDMA, "SPUwriteDMA");

-	LoadSpuSym1(readDMA, "SPUreadDMA");

-	LoadSpuSym1(writeDMAMem, "SPUwriteDMAMem");

-	LoadSpuSym1(readDMAMem, "SPUreadDMAMem");

-	LoadSpuSym1(playADPCMchannel, "SPUplayADPCMchannel");

-	LoadSpuSym1(freeze, "SPUfreeze");

-	LoadSpuSym1(registerCallback, "SPUregisterCallback");

-	LoadSpuSymN(async, "SPUasync");

-	LoadSpuSymN(playCDDAchannel, "SPUplayCDDAchannel");

-

-	return 0;

-}

-

-void *hPAD1Driver = NULL;

-void *hPAD2Driver = NULL;

-

-static unsigned char buf[256];

-unsigned char stdpar[10] = { 0x00, 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

-unsigned char mousepar[8] = { 0x00, 0x12, 0x5a, 0xff, 0xff, 0xff, 0xff };

-unsigned char analogpar[9] = { 0x00, 0xff, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

-

-static int bufcount, bufc;

-

-PadDataS padd1, padd2;

-

-unsigned char _PADstartPoll(PadDataS *pad) {

-    bufc = 0;

-

-    switch (pad->controllerType) {

-        case PSE_PAD_TYPE_MOUSE:

-            mousepar[3] = pad->buttonStatus & 0xff;

-            mousepar[4] = pad->buttonStatus >> 8;

-            mousepar[5] = pad->moveX;

-            mousepar[6] = pad->moveY;

-

-            memcpy(buf, mousepar, 7);

-            bufcount = 6;

-            break;

-        case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)

-            analogpar[1] = 0x23;

-            analogpar[3] = pad->buttonStatus & 0xff;

-            analogpar[4] = pad->buttonStatus >> 8;

-            analogpar[5] = pad->rightJoyX;

-            analogpar[6] = pad->rightJoyY;

-            analogpar[7] = pad->leftJoyX;

-            analogpar[8] = pad->leftJoyY;

-

-            memcpy(buf, analogpar, 9);

-            bufcount = 8;

-            break;

-        case PSE_PAD_TYPE_ANALOGPAD: // scph1150

-            analogpar[1] = 0x73;

-            analogpar[3] = pad->buttonStatus & 0xff;

-            analogpar[4] = pad->buttonStatus >> 8;

-            analogpar[5] = pad->rightJoyX;

-            analogpar[6] = pad->rightJoyY;

-            analogpar[7] = pad->leftJoyX;

-            analogpar[8] = pad->leftJoyY;

-

-            memcpy(buf, analogpar, 9);

-            bufcount = 8;

-            break;

-        case PSE_PAD_TYPE_ANALOGJOY: // scph1110

-            analogpar[1] = 0x53;

-            analogpar[3] = pad->buttonStatus & 0xff;

-            analogpar[4] = pad->buttonStatus >> 8;

-            analogpar[5] = pad->rightJoyX;

-            analogpar[6] = pad->rightJoyY;

-            analogpar[7] = pad->leftJoyX;

-            analogpar[8] = pad->leftJoyY;

-

-            memcpy(buf, analogpar, 9);

-            bufcount = 8;

-            break;

-        case PSE_PAD_TYPE_STANDARD:

-        default:

-            stdpar[3] = pad->buttonStatus & 0xff;

-            stdpar[4] = pad->buttonStatus >> 8;

-

-            memcpy(buf, stdpar, 5);

-            bufcount = 4;

-    }

-

-    return buf[bufc++];

-}

-

-unsigned char _PADpoll(unsigned char value) {

-    if (bufc > bufcount) return 0;

-    return buf[bufc++];

-}

-

-unsigned char CALLBACK PAD1__startPoll(int pad) {

-    PadDataS padd;

-

-    PAD1_readPort1(&padd);

-

-    return _PADstartPoll(&padd);

-}

-

-unsigned char CALLBACK PAD1__poll(unsigned char value) {

-    return _PADpoll(value);

-}

-

-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; }

-void CALLBACK PAD1__registerVibration(void (CALLBACK *callback)(unsigned long, unsigned long)) {}

-void CALLBACK PAD1__registerCursor(void (CALLBACK *callback)(int, int, int)) {}

-

-#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;

-

-	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");

-    LoadPad1Sym0(registerVibration, "PADregisterVibration");

-    LoadPad1Sym0(registerCursor, "PADregisterCursor");

-

-	return 0;

-}

-

-unsigned char CALLBACK PAD2__startPoll(int pad) {

-	PadDataS padd;

-

-	PAD2_readPort2(&padd);

-

-	return _PADstartPoll(&padd);

-}

-

-unsigned char CALLBACK PAD2__poll(unsigned char value) {

-	return _PADpoll(value);

-}

-

-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; }

-void CALLBACK PAD2__registerVibration(void (CALLBACK *callback)(unsigned long, unsigned long)) {}

-void CALLBACK PAD2__registerCursor(void (CALLBACK *callback)(int, int, int)) {}

-

-#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;

-

-	hPAD2Driver = SysLoadLibrary(PAD2dll);

-	if (hPAD2Driver == NULL) {

-		PAD2_configure = NULL;

-		SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;

-	}

-	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");

-    LoadPad2Sym0(registerVibration, "PADregisterVibration");

-    LoadPad2Sym0(registerCursor, "PADregisterCursor");

-

-	return 0;

-}

-

-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;

-	}

-	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;

-}

-

-#ifdef ENABLE_SIO1API

-

-void *hSIO1Driver = NULL;

-

-long CALLBACK SIO1__init(void) { return 0; }

-long CALLBACK SIO1__shutdown(void) { return 0; }

-long CALLBACK SIO1__open(void) { return 0; }

-long CALLBACK SIO1__close(void) { return 0; }

-long CALLBACK SIO1__configure(void) { return 0; }

-long CALLBACK SIO1__test(void) { return 0; }

-void CALLBACK SIO1__about(void) {}

-void CALLBACK SIO1__pause(void) {}

-void CALLBACK SIO1__resume(void) {}

-long CALLBACK SIO1__keypressed(int key) { return 0; }

-void CALLBACK SIO1__writeData8(unsigned char val) {}

-void CALLBACK SIO1__writeData16(unsigned short val) {}

-void CALLBACK SIO1__writeData32(unsigned long val) {}

-void CALLBACK SIO1__writeStat16(unsigned short val) {}

-void CALLBACK SIO1__writeStat32(unsigned long val) {}

-void CALLBACK SIO1__writeMode16(unsigned short val) {}

-void CALLBACK SIO1__writeMode32(unsigned long val) {}

-void CALLBACK SIO1__writeCtrl16(unsigned short val) {}

-void CALLBACK SIO1__writeCtrl32(unsigned long val) {}

-void CALLBACK SIO1__writeBaud16(unsigned short val) {}

-void CALLBACK SIO1__writeBaud32(unsigned long val) {}

-unsigned char CALLBACK SIO1__readData8(void) { return 0; }

-unsigned short CALLBACK SIO1__readData16(void) { return 0; }

-unsigned long CALLBACK SIO1__readData32(void) { return 0; }

-unsigned short CALLBACK SIO1__readStat16(void) { return 0; }

-unsigned long CALLBACK SIO1__readStat32(void) { return 0; }

-unsigned short CALLBACK SIO1__readMode16(void) { return 0; }

-unsigned long CALLBACK SIO1__readMode32(void) { return 0; }

-unsigned short CALLBACK SIO1__readCtrl16(void) { return 0; }

-unsigned long CALLBACK SIO1__readCtrl32(void) { return 0; }

-unsigned short CALLBACK SIO1__readBaud16(void) { return 0; }

-unsigned long CALLBACK SIO1__readBaud32(void) { return 0; }

-void CALLBACK SIO1__registerCallback(void (CALLBACK *callback)(void)) {};

-

-void CALLBACK SIO1irq(void) {

-    psxHu32ref(0x1070) |= SWAPu32(0x100);

-}

-

-#define LoadSio1Sym1(dest, name) \

-    LoadSym(SIO1_##dest, SIO1##dest, name, TRUE);

-

-#define LoadSio1SymN(dest, name) \

-    LoadSym(SIO1_##dest, SIO1##dest, name, FALSE);

-

-#define LoadSio1Sym0(dest, name) \

-    LoadSym(SIO1_##dest, SIO1##dest, name, FALSE); \

-    if (SIO1_##dest == NULL) SIO1_##dest = (SIO1##dest) SIO1__##dest;

-

-static int LoadSIO1plugin(const char *SIO1dll) {

-    void *drv;

-

-    hSIO1Driver = SysLoadLibrary(SIO1dll);

-    if (hSIO1Driver == NULL) {

-        SysMessage (_("Could not load SIO1 plugin %s!"), SIO1dll); return -1;

-    }

-    drv = hSIO1Driver;

-

-    LoadSio1Sym0(init, "SIO1init");

-    LoadSio1Sym0(shutdown, "SIO1shutdown");

-    LoadSio1Sym0(open, "SIO1open");

-    LoadSio1Sym0(close, "SIO1close");

-    LoadSio1Sym0(pause, "SIO1pause");

-    LoadSio1Sym0(resume, "SIO1resume");

-    LoadSio1Sym0(keypressed, "SIO1keypressed");

-    LoadSio1Sym0(configure, "SIO1configure");

-    LoadSio1Sym0(test, "SIO1test");

-    LoadSio1Sym0(about, "SIO1about");

-    LoadSio1Sym0(writeData8, "SIO1writeData8");

-    LoadSio1Sym0(writeData16, "SIO1writeData16");

-    LoadSio1Sym0(writeData32, "SIO1writeData32");

-    LoadSio1Sym0(writeStat16, "SIO1writeStat16");

-    LoadSio1Sym0(writeStat32, "SIO1writeStat32");

-    LoadSio1Sym0(writeMode16, "SIO1writeMode16");

-    LoadSio1Sym0(writeMode32, "SIO1writeMode32");

-    LoadSio1Sym0(writeCtrl16, "SIO1writeCtrl16");

-    LoadSio1Sym0(writeCtrl32, "SIO1writeCtrl32");

-    LoadSio1Sym0(writeBaud16, "SIO1writeBaud16");

-    LoadSio1Sym0(writeBaud32, "SIO1writeBaud32");

-    LoadSio1Sym0(readData16, "SIO1readData16");

-    LoadSio1Sym0(readData32, "SIO1readData32");

-    LoadSio1Sym0(readStat16, "SIO1readStat16");

-    LoadSio1Sym0(readStat32, "SIO1readStat32");

-    LoadSio1Sym0(readMode16, "SIO1readMode16");

-    LoadSio1Sym0(readMode32, "SIO1readMode32");

-    LoadSio1Sym0(readCtrl16, "SIO1readCtrl16");

-    LoadSio1Sym0(readCtrl32, "SIO1readCtrl32");

-    LoadSio1Sym0(readBaud16, "SIO1readBaud16");

-    LoadSio1Sym0(readBaud32, "SIO1readBaud32");

-    LoadSio1Sym0(registerCallback, "SIO1registerCallback");

-

-    return 0;

-}

-

-#endif

-

-void CALLBACK clearDynarec(void) {

-	psxCpu->Reset();

-}

-

-int LoadPlugins() {

-	int ret;

-	char Plugin[MAXPATHLEN];

-

-	ReleasePlugins();

-

-	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();

-	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; }

-	}

-

-#ifdef ENABLE_SIO1API

-	ret = SIO1_init();

-	if (ret < 0) { SysMessage (_("Error initializing SIO1 plugin: %d"), ret); return -1; }

-#endif

-

-	SysPrintf(_("Plugins loaded.\n"));

-	return 0;

-}

-

-void ReleasePlugins() {

-	if (Config.UseNet) {

-		int ret = NET_close();

-		if (ret < 0) Config.UseNet = FALSE;

-	}

-	NetOpened = FALSE;

-

-	if (hCDRDriver != NULL || cdrIsoActive()) CDR_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) {

-		SIO1_shutdown();

-		SysCloseLibrary(hSIO1Driver);

-		hSIO1Driver = NULL;

-	}

-#endif

-}

-

-void SetIsoFile(const char *filename) {

-	if (filename == NULL) {

-		IsoFile[0] = '\0';

-		return;

-	}

-	strncpy(IsoFile, filename, MAXPATHLEN);

-}

-

-const char *GetIsoFile(void) {

-	return IsoFile;

-}

-

-boolean UsingIso(void) {

-	return (IsoFile[0] != '\0');

-}

-

-void SetCdOpenCaseTime(s64 time) {

-	cdOpenCaseTime = time;

-}

+/***************************************************************************
+ *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, 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.           *
+ ***************************************************************************/
+
+/*
+* Plugin library callback/access functions.
+*/
+
+#include "plugins.h"
+#include "cdriso.h"
+
+static char IsoFile[MAXPATHLEN] = "";
+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;
+GPUreadData           GPU_readData;
+GPUreadDataMem        GPU_readDataMem;
+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;
+GPUclearDynarec       GPU_clearDynarec;
+GPUvBlank             GPU_vBlank;
+GPUregisterCallback   GPU_registerCallback;
+GPUidle               GPU_idle;
+GPUvisualVibration    GPU_visualVibration;
+GPUcursor             GPU_cursor;
+
+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;
+
+SPUconfigure          SPU_configure;
+SPUabout              SPU_about;
+SPUinit               SPU_init;
+SPUshutdown           SPU_shutdown;
+SPUtest               SPU_test;
+SPUopen               SPU_open;
+SPUclose              SPU_close;
+SPUplaySample         SPU_playSample;
+SPUwriteRegister      SPU_writeRegister;
+SPUreadRegister       SPU_readRegister;
+SPUwriteDMA           SPU_writeDMA;
+SPUreadDMA            SPU_readDMA;
+SPUwriteDMAMem        SPU_writeDMAMem;
+SPUreadDMAMem         SPU_readDMAMem;
+SPUplayADPCMchannel   SPU_playADPCMchannel;
+SPUfreeze             SPU_freeze;
+SPUregisterCallback   SPU_registerCallback;
+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;
+PADregisterVibration  PAD1_registerVibration;
+PADregisterCursor     PAD1_registerCursor;
+
+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;
+PADregisterVibration  PAD2_registerVibration;
+PADregisterCursor     PAD2_registerCursor;
+
+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;
+
+#ifdef ENABLE_SIO1API
+
+SIO1init              SIO1_init;
+SIO1shutdown          SIO1_shutdown;
+SIO1open              SIO1_open;
+SIO1close             SIO1_close;
+SIO1test              SIO1_test;
+SIO1configure         SIO1_configure;
+SIO1about             SIO1_about;
+SIO1pause             SIO1_pause;
+SIO1resume            SIO1_resume;
+SIO1keypressed        SIO1_keypressed;
+SIO1writeData8        SIO1_writeData8;
+SIO1writeData16       SIO1_writeData16;
+SIO1writeData32       SIO1_writeData32;
+SIO1writeStat16       SIO1_writeStat16;
+SIO1writeStat32       SIO1_writeStat32;
+SIO1writeMode16       SIO1_writeMode16;
+SIO1writeMode32       SIO1_writeMode32;
+SIO1writeCtrl16       SIO1_writeCtrl16;
+SIO1writeCtrl32       SIO1_writeCtrl32;
+SIO1writeBaud16       SIO1_writeBaud16;
+SIO1writeBaud32       SIO1_writeBaud32;
+SIO1readData8         SIO1_readData8;
+SIO1readData16        SIO1_readData16;
+SIO1readData32        SIO1_readData32;
+SIO1readStat16        SIO1_readStat16;
+SIO1readStat32        SIO1_readStat32;
+SIO1readMode16        SIO1_readMode16;
+SIO1readMode32        SIO1_readMode32;
+SIO1readCtrl16        SIO1_readCtrl16;
+SIO1readCtrl32        SIO1_readCtrl32;
+SIO1readBaud16        SIO1_readBaud16;
+SIO1readBaud32        SIO1_readBaud32;
+SIO1registerCallback  SIO1_registerCallback;
+
+#endif
+
+static const char *err;
+
+#define CheckErr(func) { \
+	err = SysLibError(); \
+	if (err != NULL) { SysMessage(_("Error loading %s: %s"), func, err); return -1; } \
+}
+
+#define LoadSym(dest, src, name, checkerr) { \
+	dest = (src)SysLoadSym(drv, name); \
+	if (checkerr) { CheckErr(name); } else SysLibError(); \
+}
+
+void *hGPUDriver = NULL;
+
+static void CALLBACK GPU__displayText(char *pText) {
+	SysPrintf("%s\n", pText);
+}
+
+void CALLBACK GPUbusy( int ticks )
+{
+    //printf( "GPUbusy( %i )\n", ticks );
+    //fflush( 0 );
+
+    psxRegs.interrupt |= (1 << PSXINT_GPUBUSY);
+    psxRegs.intCycle[PSXINT_GPUBUSY].cycle = ticks;
+    psxRegs.intCycle[PSXINT_GPUBUSY].sCycle = psxRegs.cycle;
+}
+
+static long CALLBACK GPU__configure(void) { return 0; }
+static long CALLBACK GPU__test(void) { return 0; }
+static void CALLBACK GPU__about(void) {}
+static void CALLBACK GPU__makeSnapshot(void) {}
+static void CALLBACK GPU__keypressed(int key) {}
+static long CALLBACK GPU__getScreenPic(unsigned char *pMem) { return -1; }
+static long CALLBACK GPU__showScreenPic(unsigned char *pMem) { return -1; }
+static void CALLBACK GPU__clearDynarec(void (CALLBACK *callback)(void)) {}
+static void CALLBACK GPU__vBlank(int val) {}
+static void CALLBACK GPU__registerCallback(void (CALLBACK *callback)(int)) {}
+static void CALLBACK GPU__idle(void) {}
+static void CALLBACK GPU__visualVibration(unsigned long iSmall, unsigned long iBig) {}
+static void CALLBACK GPU__cursor(int player, int x, int y) {}
+
+#define LoadGpuSym1(dest, name) \
+	LoadSym(GPU_##dest, GPU##dest, name, TRUE);
+
+#define LoadGpuSym0(dest, name) \
+	LoadSym(GPU_##dest, GPU##dest, name, FALSE); \
+	if (GPU_##dest == NULL) GPU_##dest = (GPU##dest) GPU__##dest;
+
+#define LoadGpuSymN(dest, name) \
+	LoadSym(GPU_##dest, GPU##dest, name, FALSE);
+
+static int LoadGPUplugin(const char *GPUdll) {
+	void *drv;
+
+	hGPUDriver = SysLoadLibrary(GPUdll);
+	if (hGPUDriver == NULL) {
+		GPU_configure = NULL;
+		SysMessage (_("Could not load GPU plugin %s!"), GPUdll); return -1;
+	}
+	drv = hGPUDriver;
+	LoadGpuSym1(init, "GPUinit");
+	LoadGpuSym1(shutdown, "GPUshutdown");
+	LoadGpuSym1(open, "GPUopen");
+	LoadGpuSym1(close, "GPUclose");
+	LoadGpuSym1(readData, "GPUreadData");
+	LoadGpuSym1(readDataMem, "GPUreadDataMem");
+	LoadGpuSym1(readStatus, "GPUreadStatus");
+	LoadGpuSym1(writeData, "GPUwriteData");
+	LoadGpuSym1(writeDataMem, "GPUwriteDataMem");
+	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(clearDynarec, "GPUclearDynarec");
+    LoadGpuSym0(vBlank, "GPUvBlank");
+    LoadGpuSym0(registerCallback, "GPUregisterCallback");
+    LoadGpuSym0(idle, "GPUidle");
+    LoadGpuSym0(visualVibration, "GPUvisualVibration");
+    LoadGpuSym0(cursor, "GPUcursor");
+	LoadGpuSym0(configure, "GPUconfigure");
+	LoadGpuSym0(test, "GPUtest");
+	LoadGpuSym0(about, "GPUabout");
+
+	return 0;
+}
+
+void *hCDRDriver = NULL;
+
+static long CALLBACK CDR__play(unsigned char *sector) { return 0; }
+static long CALLBACK CDR__stop(void) { return 0; }
+
+long CALLBACK CDR__getStatus(struct CdrStat *stat) {
+	if (cdOpenCaseTime < 0 || cdOpenCaseTime > (s64)time(NULL))
+		stat->Status = 0x10;
+	else
+		stat->Status = 0;
+
+	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;
+}
+
+void *hSPUDriver = NULL;
+
+static long CALLBACK SPU__configure(void) { return 0; }
+static void CALLBACK SPU__about(void) {}
+static long CALLBACK SPU__test(void) { return 0; }
+
+#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;
+
+#define LoadSpuSymN(dest, name) \
+	LoadSym(SPU_##dest, SPU##dest, name, FALSE);
+
+static int LoadSPUplugin(const char *SPUdll) {
+	void *drv;
+
+	hSPUDriver = SysLoadLibrary(SPUdll);
+	if (hSPUDriver == NULL) {
+		SPU_configure = NULL;
+		SysMessage (_("Could not load SPU plugin %s!"), SPUdll); return -1;
+	}
+	drv = hSPUDriver;
+	LoadSpuSym1(init, "SPUinit");
+	LoadSpuSym1(shutdown, "SPUshutdown");
+	LoadSpuSym1(open, "SPUopen");
+	LoadSpuSym1(close, "SPUclose");
+	LoadSpuSym0(configure, "SPUconfigure");
+	LoadSpuSym0(about, "SPUabout");
+	LoadSpuSym0(test, "SPUtest");
+	LoadSpuSym1(writeRegister, "SPUwriteRegister");
+	LoadSpuSym1(readRegister, "SPUreadRegister");
+	LoadSpuSym1(writeDMA, "SPUwriteDMA");
+	LoadSpuSym1(readDMA, "SPUreadDMA");
+	LoadSpuSym1(writeDMAMem, "SPUwriteDMAMem");
+	LoadSpuSym1(readDMAMem, "SPUreadDMAMem");
+	LoadSpuSym1(playADPCMchannel, "SPUplayADPCMchannel");
+	LoadSpuSym1(freeze, "SPUfreeze");
+	LoadSpuSym1(registerCallback, "SPUregisterCallback");
+	LoadSpuSymN(async, "SPUasync");
+	LoadSpuSymN(playCDDAchannel, "SPUplayCDDAchannel");
+
+	return 0;
+}
+
+void *hPAD1Driver = NULL;
+void *hPAD2Driver = NULL;
+
+static unsigned char buf[256];
+unsigned char stdpar[10] = { 0x00, 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+unsigned char mousepar[8] = { 0x00, 0x12, 0x5a, 0xff, 0xff, 0xff, 0xff };
+unsigned char analogpar[9] = { 0x00, 0xff, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+
+static int bufcount, bufc;
+
+PadDataS padd1, padd2;
+
+static unsigned char _PADstartPoll(PadDataS *pad) {
+    bufc = 0;
+
+    switch (pad->controllerType) {
+        case PSE_PAD_TYPE_MOUSE:
+            mousepar[3] = pad->buttonStatus & 0xff;
+            mousepar[4] = pad->buttonStatus >> 8;
+            mousepar[5] = pad->moveX;
+            mousepar[6] = pad->moveY;
+
+            memcpy(buf, mousepar, 7);
+            bufcount = 6;
+            break;
+        case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)
+            analogpar[1] = 0x23;
+            analogpar[3] = pad->buttonStatus & 0xff;
+            analogpar[4] = pad->buttonStatus >> 8;
+            analogpar[5] = pad->rightJoyX;
+            analogpar[6] = pad->rightJoyY;
+            analogpar[7] = pad->leftJoyX;
+            analogpar[8] = pad->leftJoyY;
+
+            memcpy(buf, analogpar, 9);
+            bufcount = 8;
+            break;
+        case PSE_PAD_TYPE_ANALOGPAD: // scph1150
+            analogpar[1] = 0x73;
+            analogpar[3] = pad->buttonStatus & 0xff;
+            analogpar[4] = pad->buttonStatus >> 8;
+            analogpar[5] = pad->rightJoyX;
+            analogpar[6] = pad->rightJoyY;
+            analogpar[7] = pad->leftJoyX;
+            analogpar[8] = pad->leftJoyY;
+
+            memcpy(buf, analogpar, 9);
+            bufcount = 8;
+            break;
+        case PSE_PAD_TYPE_ANALOGJOY: // scph1110
+            analogpar[1] = 0x53;
+            analogpar[3] = pad->buttonStatus & 0xff;
+            analogpar[4] = pad->buttonStatus >> 8;
+            analogpar[5] = pad->rightJoyX;
+            analogpar[6] = pad->rightJoyY;
+            analogpar[7] = pad->leftJoyX;
+            analogpar[8] = pad->leftJoyY;
+
+            memcpy(buf, analogpar, 9);
+            bufcount = 8;
+            break;
+        case PSE_PAD_TYPE_STANDARD:
+        default:
+            stdpar[3] = pad->buttonStatus & 0xff;
+            stdpar[4] = pad->buttonStatus >> 8;
+
+            memcpy(buf, stdpar, 5);
+            bufcount = 4;
+    }
+
+    return buf[bufc++];
+}
+
+static unsigned char _PADpoll(unsigned char value) {
+    if (bufc > bufcount) return 0;
+    return buf[bufc++];
+}
+
+static unsigned char CALLBACK PAD1__startPoll(int pad) {
+    PadDataS padd;
+
+    PAD1_readPort1(&padd);
+
+    return _PADstartPoll(&padd);
+}
+
+static unsigned char CALLBACK PAD1__poll(unsigned char value) {
+    return _PADpoll(value);
+}
+
+static long CALLBACK PAD1__configure(void) { return 0; }
+static void CALLBACK PAD1__about(void) {}
+static long CALLBACK PAD1__test(void) { return 0; }
+static long CALLBACK PAD1__query(void) { return 3; }
+static long CALLBACK PAD1__keypressed() { return 0; }
+static void CALLBACK PAD1__registerVibration(void (CALLBACK *callback)(unsigned long, unsigned long)) {}
+static void CALLBACK PAD1__registerCursor(void (CALLBACK *callback)(int, int, int)) {}
+
+#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;
+
+	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");
+    LoadPad1Sym0(registerVibration, "PADregisterVibration");
+    LoadPad1Sym0(registerCursor, "PADregisterCursor");
+
+	return 0;
+}
+
+static unsigned char CALLBACK PAD2__startPoll(int pad) {
+	PadDataS padd;
+
+	PAD2_readPort2(&padd);
+
+	return _PADstartPoll(&padd);
+}
+
+static unsigned char CALLBACK PAD2__poll(unsigned char value) {
+	return _PADpoll(value);
+}
+
+static long CALLBACK PAD2__configure(void) { return 0; }
+static void CALLBACK PAD2__about(void) {}
+static long CALLBACK PAD2__test(void) { return 0; }
+static long CALLBACK PAD2__query(void) { return PSE_PAD_USE_PORT1 | PSE_PAD_USE_PORT2; }
+static long CALLBACK PAD2__keypressed() { return 0; }
+static void CALLBACK PAD2__registerVibration(void (CALLBACK *callback)(unsigned long, unsigned long)) {}
+static void CALLBACK PAD2__registerCursor(void (CALLBACK *callback)(int, int, int)) {}
+
+#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;
+
+	hPAD2Driver = SysLoadLibrary(PAD2dll);
+	if (hPAD2Driver == NULL) {
+		PAD2_configure = NULL;
+		SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;
+	}
+	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");
+    LoadPad2Sym0(registerVibration, "PADregisterVibration");
+    LoadPad2Sym0(registerCursor, "PADregisterCursor");
+
+	return 0;
+}
+
+void *hNETDriver = NULL;
+
+static void CALLBACK NET__setInfo(netInfo *info) {}
+static void CALLBACK NET__keypressed(int key) {}
+static long CALLBACK NET__configure(void) { return 0; }
+static long CALLBACK NET__test(void) { return 0; }
+static 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;
+	}
+	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;
+}
+
+#ifdef ENABLE_SIO1API
+
+void *hSIO1Driver = NULL;
+
+static long CALLBACK SIO1__init(void) { return 0; }
+static long CALLBACK SIO1__shutdown(void) { return 0; }
+static long CALLBACK SIO1__open(void) { return 0; }
+static long CALLBACK SIO1__close(void) { return 0; }
+static long CALLBACK SIO1__configure(void) { return 0; }
+static long CALLBACK SIO1__test(void) { return 0; }
+static void CALLBACK SIO1__about(void) {}
+static void CALLBACK SIO1__pause(void) {}
+static void CALLBACK SIO1__resume(void) {}
+static long CALLBACK SIO1__keypressed(int key) { return 0; }
+static void CALLBACK SIO1__writeData8(unsigned char val) {}
+static void CALLBACK SIO1__writeData16(unsigned short val) {}
+static void CALLBACK SIO1__writeData32(unsigned long val) {}
+static void CALLBACK SIO1__writeStat16(unsigned short val) {}
+static void CALLBACK SIO1__writeStat32(unsigned long val) {}
+static void CALLBACK SIO1__writeMode16(unsigned short val) {}
+static void CALLBACK SIO1__writeMode32(unsigned long val) {}
+static void CALLBACK SIO1__writeCtrl16(unsigned short val) {}
+static void CALLBACK SIO1__writeCtrl32(unsigned long val) {}
+static void CALLBACK SIO1__writeBaud16(unsigned short val) {}
+static void CALLBACK SIO1__writeBaud32(unsigned long val) {}
+static unsigned char CALLBACK SIO1__readData8(void) { return 0; }
+static unsigned short CALLBACK SIO1__readData16(void) { return 0; }
+static unsigned long CALLBACK SIO1__readData32(void) { return 0; }
+static unsigned short CALLBACK SIO1__readStat16(void) { return 0; }
+static unsigned long CALLBACK SIO1__readStat32(void) { return 0; }
+static unsigned short CALLBACK SIO1__readMode16(void) { return 0; }
+static unsigned long CALLBACK SIO1__readMode32(void) { return 0; }
+static unsigned short CALLBACK SIO1__readCtrl16(void) { return 0; }
+static unsigned long CALLBACK SIO1__readCtrl32(void) { return 0; }
+static unsigned short CALLBACK SIO1__readBaud16(void) { return 0; }
+static unsigned long CALLBACK SIO1__readBaud32(void) { return 0; }
+static void CALLBACK SIO1__registerCallback(void (CALLBACK *callback)(void)) {};
+
+#if 0 // unused by pcsxr
+void CALLBACK SIO1irq(void) {
+    psxHu32ref(0x1070) |= SWAPu32(0x100);
+}
+#endif
+
+#define LoadSio1Sym1(dest, name) \
+    LoadSym(SIO1_##dest, SIO1##dest, name, TRUE);
+
+#define LoadSio1SymN(dest, name) \
+    LoadSym(SIO1_##dest, SIO1##dest, name, FALSE);
+
+#define LoadSio1Sym0(dest, name) \
+    LoadSym(SIO1_##dest, SIO1##dest, name, FALSE); \
+    if (SIO1_##dest == NULL) SIO1_##dest = (SIO1##dest) SIO1__##dest;
+
+static int LoadSIO1plugin(const char *SIO1dll) {
+    void *drv;
+
+    hSIO1Driver = SysLoadLibrary(SIO1dll);
+    if (hSIO1Driver == NULL) {
+        SysMessage (_("Could not load SIO1 plugin %s!"), SIO1dll); return -1;
+    }
+    drv = hSIO1Driver;
+
+    LoadSio1Sym0(init, "SIO1init");
+    LoadSio1Sym0(shutdown, "SIO1shutdown");
+    LoadSio1Sym0(open, "SIO1open");
+    LoadSio1Sym0(close, "SIO1close");
+    LoadSio1Sym0(pause, "SIO1pause");
+    LoadSio1Sym0(resume, "SIO1resume");
+    LoadSio1Sym0(keypressed, "SIO1keypressed");
+    LoadSio1Sym0(configure, "SIO1configure");
+    LoadSio1Sym0(test, "SIO1test");
+    LoadSio1Sym0(about, "SIO1about");
+    LoadSio1Sym0(writeData8, "SIO1writeData8");
+    LoadSio1Sym0(writeData16, "SIO1writeData16");
+    LoadSio1Sym0(writeData32, "SIO1writeData32");
+    LoadSio1Sym0(writeStat16, "SIO1writeStat16");
+    LoadSio1Sym0(writeStat32, "SIO1writeStat32");
+    LoadSio1Sym0(writeMode16, "SIO1writeMode16");
+    LoadSio1Sym0(writeMode32, "SIO1writeMode32");
+    LoadSio1Sym0(writeCtrl16, "SIO1writeCtrl16");
+    LoadSio1Sym0(writeCtrl32, "SIO1writeCtrl32");
+    LoadSio1Sym0(writeBaud16, "SIO1writeBaud16");
+    LoadSio1Sym0(writeBaud32, "SIO1writeBaud32");
+    LoadSio1Sym0(readData8, "SIO1readData8");
+    LoadSio1Sym0(readData16, "SIO1readData16");
+    LoadSio1Sym0(readData32, "SIO1readData32");
+    LoadSio1Sym0(readStat16, "SIO1readStat16");
+    LoadSio1Sym0(readStat32, "SIO1readStat32");
+    LoadSio1Sym0(readMode16, "SIO1readMode16");
+    LoadSio1Sym0(readMode32, "SIO1readMode32");
+    LoadSio1Sym0(readCtrl16, "SIO1readCtrl16");
+    LoadSio1Sym0(readCtrl32, "SIO1readCtrl32");
+    LoadSio1Sym0(readBaud16, "SIO1readBaud16");
+    LoadSio1Sym0(readBaud32, "SIO1readBaud32");
+    LoadSio1Sym0(registerCallback, "SIO1registerCallback");
+
+    return 0;
+}
+
+#endif
+
+void CALLBACK clearDynarec(void) {
+	psxCpu->Reset();
+}
+
+int LoadPlugins() {
+	int ret;
+	char Plugin[MAXPATHLEN];
+
+	ReleasePlugins();
+
+	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();
+	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; }
+	}
+
+#ifdef ENABLE_SIO1API
+	ret = SIO1_init();
+	if (ret < 0) { SysMessage (_("Error initializing SIO1 plugin: %d"), ret); return -1; }
+#endif
+
+	SysPrintf(_("Plugins loaded.\n"));
+	return 0;
+}
+
+void ReleasePlugins() {
+	if (Config.UseNet) {
+		int ret = NET_close();
+		if (ret < 0) Config.UseNet = FALSE;
+	}
+	NetOpened = FALSE;
+
+	if (hCDRDriver != NULL || cdrIsoActive()) CDR_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) {
+		SIO1_shutdown();
+		SysCloseLibrary(hSIO1Driver);
+		hSIO1Driver = NULL;
+	}
+#endif
+}
+
+void SetIsoFile(const char *filename) {
+	if (filename == NULL) {
+		IsoFile[0] = '\0';
+		return;
+	}
+	strncpy(IsoFile, filename, MAXPATHLEN);
+}
+
+const char *GetIsoFile(void) {
+	return IsoFile;
+}
+
+boolean UsingIso(void) {
+	return (IsoFile[0] != '\0');
+}
+
+void SetCdOpenCaseTime(s64 time) {
+	cdOpenCaseTime = time;
+}
diff --git a/libpcsxcore/plugins.h b/libpcsxcore/plugins.h
index 4a90c367..be188a4f 100644
--- a/libpcsxcore/plugins.h
+++ b/libpcsxcore/plugins.h
@@ -1,426 +1,223 @@
-/***************************************************************************

- *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, 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.           *

- ***************************************************************************/

-

-#ifndef __PLUGINS_H__

-#define __PLUGINS_H__

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-#include "psxcommon.h"

-

-//#define ENABLE_SIO1API 1

-

-#ifndef _WIN32

-

-typedef void* HWND;

-#define CALLBACK

-

-typedef long (*GPUopen)(unsigned long *, char *, char *);

-typedef long (*SPUopen)(void);

-typedef long (*PADopen)(unsigned long *);

-typedef long (*NETopen)(unsigned long *);

-typedef long (*SIO1open)(unsigned long *);

-

-#else

-

-#include <windows.h>

-

-typedef long (CALLBACK* GPUopen)(HWND);

-typedef long (CALLBACK* SPUopen)(HWND);

-typedef long (CALLBACK* PADopen)(HWND);

-typedef long (CALLBACK* NETopen)(HWND);

-typedef long (CALLBACK* SIO1open)(HWND);

-

-#endif

-

-#include "spu.h"

-

-#include "psemu_plugin_defs.h"

-#include "decode_xa.h"

-

-int LoadPlugins();

-void ReleasePlugins();

-int OpenPlugins();

-void ClosePlugins();

-

-typedef unsigned long (CALLBACK* PSEgetLibType)(void);

-typedef unsigned long (CALLBACK* PSEgetLibVersion)(void);

-typedef char *(CALLBACK* PSEgetLibName)(void);

-

-// GPU Functions

-typedef long (CALLBACK* GPUinit)(void);

-typedef long (CALLBACK* GPUshutdown)(void);

-typedef long (CALLBACK* GPUclose)(void);

-typedef void (CALLBACK* GPUwriteStatus)(uint32_t);

-typedef void (CALLBACK* GPUwriteData)(uint32_t);

-typedef void (CALLBACK* GPUwriteDataMem)(uint32_t *, int);

-typedef uint32_t (CALLBACK* GPUreadStatus)(void);

-typedef uint32_t (CALLBACK* GPUreadData)(void);

-typedef void (CALLBACK* GPUreadDataMem)(uint32_t *, int);

-typedef long (CALLBACK* GPUdmaChain)(uint32_t *,uint32_t);

-typedef void (CALLBACK* GPUupdateLace)(void);

-typedef long (CALLBACK* GPUconfigure)(void);

-typedef long (CALLBACK* GPUtest)(void);

-typedef void (CALLBACK* GPUabout)(void);

-typedef void (CALLBACK* GPUmakeSnapshot)(void);

-typedef void (CALLBACK* GPUkeypressed)(int);

-typedef void (CALLBACK* GPUdisplayText)(char *);

-typedef struct {

-	uint32_t ulFreezeVersion;

-	uint32_t ulStatus;

-	uint32_t ulControl[256];

-	unsigned char psxVRam[1024*512*2];

-} GPUFreeze_t;

-typedef long (CALLBACK* GPUfreeze)(uint32_t, GPUFreeze_t *);

-typedef long (CALLBACK* GPUgetScreenPic)(unsigned char *);

-typedef long (CALLBACK* GPUshowScreenPic)(unsigned char *);

-typedef void (CALLBACK* GPUclearDynarec)(void (CALLBACK *callback)(void));

-typedef void (CALLBACK* GPUvBlank)(int);

-typedef void (CALLBACK* GPUregisterCallback)(void (CALLBACK *callback)(int));

-typedef void (CALLBACK* GPUidle)(void);

-typedef void (CALLBACK* GPUvisualVibration)(uint32_t, uint32_t);

-typedef void (CALLBACK* GPUcursor)(int, int, int);

-

-// GPU function pointers

-extern GPUupdateLace    GPU_updateLace;

-extern GPUinit          GPU_init;

-extern GPUshutdown      GPU_shutdown;

-extern GPUconfigure     GPU_configure;

-extern GPUtest          GPU_test;

-extern GPUabout         GPU_about;

-extern GPUopen          GPU_open;

-extern GPUclose         GPU_close;

-extern GPUreadStatus    GPU_readStatus;

-extern GPUreadData      GPU_readData;

-extern GPUreadDataMem   GPU_readDataMem;

-extern GPUwriteStatus   GPU_writeStatus;

-extern GPUwriteData     GPU_writeData;

-extern GPUwriteDataMem  GPU_writeDataMem;

-extern GPUdmaChain      GPU_dmaChain;

-extern GPUkeypressed    GPU_keypressed;

-extern GPUdisplayText   GPU_displayText;

-extern GPUmakeSnapshot  GPU_makeSnapshot;

-extern GPUfreeze        GPU_freeze;

-extern GPUgetScreenPic  GPU_getScreenPic;

-extern GPUshowScreenPic GPU_showScreenPic;

-extern GPUclearDynarec  GPU_clearDynarec;

-extern GPUvBlank        GPU_vBlank;

-extern GPUregisterCallback GPU_registerCallback;

-extern GPUidle          GPU_idle;

-extern GPUvisualVibration GPU_visualVibration;

-extern GPUcursor        GPU_cursor;

-

-// CD-ROM Functions

-typedef long (CALLBACK* CDRinit)(void);

-typedef long (CALLBACK* CDRshutdown)(void);

-typedef long (CALLBACK* CDRopen)(void);

-typedef long (CALLBACK* CDRclose)(void);

-typedef long (CALLBACK* CDRgetTN)(unsigned char *);

-typedef long (CALLBACK* CDRgetTD)(unsigned char, unsigned char *);

-typedef long (CALLBACK* CDRreadTrack)(unsigned char *);

-typedef unsigned char* (CALLBACK* CDRgetBuffer)(void);

-typedef unsigned char* (CALLBACK* CDRgetBufferSub)(void);

-typedef long (CALLBACK* CDRconfigure)(void);

-typedef long (CALLBACK* CDRtest)(void);

-typedef void (CALLBACK* CDRabout)(void);

-typedef long (CALLBACK* CDRplay)(unsigned char *);

-typedef long (CALLBACK* CDRstop)(void);

-typedef long (CALLBACK* CDRsetfilename)(char *);

-struct CdrStat {

-	uint32_t Type;

-	uint32_t Status;

-	unsigned char Time[3];

-};

-typedef long (CALLBACK* CDRgetStatus)(struct CdrStat *);

-typedef char* (CALLBACK* CDRgetDriveLetter)(void);

-struct SubQ {

-	char res0[12];

-	unsigned char ControlAndADR;

-	unsigned char TrackNumber;

-	unsigned char IndexNumber;

-	unsigned char TrackRelativeAddress[3];

-	unsigned char Filler;

-	unsigned char AbsoluteAddress[3];

-	unsigned char CRC[2];

-	char res1[72];

-};

-typedef long (CALLBACK* CDRreadCDDA)(unsigned char, unsigned char, unsigned char, unsigned char *);

-typedef long (CALLBACK* CDRgetTE)(unsigned char, unsigned char *, unsigned char *, unsigned char *);

-

-// CD-ROM function pointers

-extern CDRinit               CDR_init;

-extern CDRshutdown           CDR_shutdown;

-extern CDRopen               CDR_open;

-extern CDRclose              CDR_close;

-extern CDRtest               CDR_test;

-extern CDRgetTN              CDR_getTN;

-extern CDRgetTD              CDR_getTD;

-extern CDRreadTrack          CDR_readTrack;

-extern CDRgetBuffer          CDR_getBuffer;

-extern CDRgetBufferSub       CDR_getBufferSub;

-extern CDRplay               CDR_play;

-extern CDRstop               CDR_stop;

-extern CDRgetStatus          CDR_getStatus;

-extern CDRgetDriveLetter     CDR_getDriveLetter;

-extern CDRconfigure          CDR_configure;

-extern CDRabout              CDR_about;

-extern CDRsetfilename        CDR_setfilename;

-extern CDRreadCDDA           CDR_readCDDA;

-extern CDRgetTE              CDR_getTE;

-

-// SPU Functions

-typedef long (CALLBACK* SPUinit)(void);

-typedef long (CALLBACK* SPUshutdown)(void);

-typedef long (CALLBACK* SPUclose)(void);

-typedef void (CALLBACK* SPUplaySample)(unsigned char);

-typedef void (CALLBACK* SPUwriteRegister)(unsigned long, unsigned short);

-typedef unsigned short (CALLBACK* SPUreadRegister)(unsigned long);

-typedef void (CALLBACK* SPUwriteDMA)(unsigned short);

-typedef unsigned short (CALLBACK* SPUreadDMA)(void);

-typedef void (CALLBACK* SPUwriteDMAMem)(unsigned short *, int);

-typedef void (CALLBACK* SPUreadDMAMem)(unsigned short *, int);

-typedef void (CALLBACK* SPUplayADPCMchannel)(xa_decode_t *);

-typedef void (CALLBACK* SPUregisterCallback)(void (CALLBACK *callback)(void));

-typedef long (CALLBACK* SPUconfigure)(void);

-typedef long (CALLBACK* SPUtest)(void);

-typedef void (CALLBACK* SPUabout)(void);

-typedef struct {

-	unsigned char PluginName[8];

-	uint32_t PluginVersion;

-	uint32_t Size;

-	unsigned char SPUPorts[0x200];

-	unsigned char SPURam[0x80000];

-	xa_decode_t xa;

-	unsigned char *SPUInfo;

-} SPUFreeze_t;

-typedef long (CALLBACK* SPUfreeze)(uint32_t, SPUFreeze_t *);

-typedef void (CALLBACK* SPUasync)(uint32_t);

-typedef void (CALLBACK* SPUplayCDDAchannel)(short *, int);

-

-// SPU function pointers

-extern SPUconfigure        SPU_configure;

-extern SPUabout            SPU_about;

-extern SPUinit             SPU_init;

-extern SPUshutdown         SPU_shutdown;

-extern SPUtest             SPU_test;

-extern SPUopen             SPU_open;

-extern SPUclose            SPU_close;

-extern SPUplaySample       SPU_playSample;

-extern SPUwriteRegister    SPU_writeRegister;

-extern SPUreadRegister     SPU_readRegister;

-extern SPUwriteDMA         SPU_writeDMA;

-extern SPUreadDMA          SPU_readDMA;

-extern SPUwriteDMAMem      SPU_writeDMAMem;

-extern SPUreadDMAMem       SPU_readDMAMem;

-extern SPUplayADPCMchannel SPU_playADPCMchannel;

-extern SPUfreeze           SPU_freeze;

-extern SPUregisterCallback SPU_registerCallback;

-extern SPUasync            SPU_async;

-extern SPUplayCDDAchannel  SPU_playCDDAchannel;

-

-// PAD Functions

-typedef long (CALLBACK* PADconfigure)(void);

-typedef void (CALLBACK* PADabout)(void);

-typedef long (CALLBACK* PADinit)(long);

-typedef long (CALLBACK* PADshutdown)(void);

-typedef long (CALLBACK* PADtest)(void);

-typedef long (CALLBACK* PADclose)(void);

-typedef long (CALLBACK* PADquery)(void);

-typedef long (CALLBACK* PADreadPort1)(PadDataS*);

-typedef long (CALLBACK* PADreadPort2)(PadDataS*);

-typedef long (CALLBACK* PADkeypressed)(void);

-typedef unsigned char (CALLBACK* PADstartPoll)(int);

-typedef unsigned char (CALLBACK* PADpoll)(unsigned char);

-typedef void (CALLBACK* PADsetSensitive)(int);

-typedef void (CALLBACK* PADregisterVibration)(void (CALLBACK *callback)(uint32_t, uint32_t));

-typedef void (CALLBACK* PADregisterCursor)(void (CALLBACK *callback)(int, int, int));

-

-// PAD function pointers

-extern PADconfigure        PAD1_configure;

-extern PADabout            PAD1_about;

-extern PADinit             PAD1_init;

-extern PADshutdown         PAD1_shutdown;

-extern PADtest             PAD1_test;

-extern PADopen             PAD1_open;

-extern PADclose            PAD1_close;

-extern PADquery            PAD1_query;

-extern PADreadPort1        PAD1_readPort1;

-extern PADkeypressed       PAD1_keypressed;

-extern PADstartPoll        PAD1_startPoll;

-extern PADpoll             PAD1_poll;

-extern PADsetSensitive     PAD1_setSensitive;

-extern PADregisterVibration PAD1_registerVibration;

-extern PADregisterCursor   PAD1_registerCursor;

-extern PADconfigure        PAD2_configure;

-extern PADabout            PAD2_about;

-extern PADinit             PAD2_init;

-extern PADshutdown         PAD2_shutdown;

-extern PADtest             PAD2_test;

-extern PADopen             PAD2_open;

-extern PADclose            PAD2_close;

-extern PADquery            PAD2_query;

-extern PADreadPort2        PAD2_readPort2;

-extern PADkeypressed       PAD2_keypressed;

-extern PADstartPoll        PAD2_startPoll;

-extern PADpoll             PAD2_poll;

-extern PADsetSensitive     PAD2_setSensitive;

-extern PADregisterVibration PAD2_registerVibration;

-extern PADregisterCursor   PAD2_registerCursor;

-

-// NET Functions

-typedef long (CALLBACK* NETinit)(void);

-typedef long (CALLBACK* NETshutdown)(void);

-typedef long (CALLBACK* NETclose)(void);

-typedef long (CALLBACK* NETconfigure)(void);

-typedef long (CALLBACK* NETtest)(void);

-typedef void (CALLBACK* NETabout)(void);

-typedef void (CALLBACK* NETpause)(void);

-typedef void (CALLBACK* NETresume)(void);

-typedef long (CALLBACK* NETqueryPlayer)(void);

-typedef long (CALLBACK* NETsendData)(void *, int, int);

-typedef long (CALLBACK* NETrecvData)(void *, int, int);

-typedef long (CALLBACK* NETsendPadData)(void *, int);

-typedef long (CALLBACK* NETrecvPadData)(void *, int);

-

-typedef struct {

-	char EmuName[32];

-	char CdromID[9];	// ie. 'SCPH12345', no \0 trailing character

-	char CdromLabel[11];

-	void *psxMem;

-	GPUshowScreenPic GPU_showScreenPic;

-	GPUdisplayText GPU_displayText;

-	PADsetSensitive PAD_setSensitive;

-	char GPUpath[256];	// paths must be absolute

-	char SPUpath[256];

-	char CDRpath[256];

-	char MCD1path[256];

-	char MCD2path[256];

-	char BIOSpath[256];	// 'HLE' for internal bios

-	char Unused[1024];

-} netInfo;

-

-typedef long (CALLBACK* NETsetInfo)(netInfo *);

-typedef long (CALLBACK* NETkeypressed)(int);

-

-// NET function pointers

-extern NETinit               NET_init;

-extern NETshutdown           NET_shutdown;

-extern NETopen               NET_open;

-extern NETclose              NET_close;

-extern NETtest               NET_test;

-extern NETconfigure          NET_configure;

-extern NETabout              NET_about;

-extern NETpause              NET_pause;

-extern NETresume             NET_resume;

-extern NETqueryPlayer        NET_queryPlayer;

-extern NETsendData           NET_sendData;

-extern NETrecvData           NET_recvData;

-extern NETsendPadData        NET_sendPadData;

-extern NETrecvPadData        NET_recvPadData;

-extern NETsetInfo            NET_setInfo;

-extern NETkeypressed         NET_keypressed;

-

-#ifdef ENABLE_SIO1API

-

-// SIO1 Functions (link cable)

-typedef long (CALLBACK* SIO1init)(void);

-typedef long (CALLBACK* SIO1shutdown)(void);

-typedef long (CALLBACK* SIO1close)(void);

-typedef long (CALLBACK* SIO1configure)(void);

-typedef long (CALLBACK* SIO1test)(void);

-typedef void (CALLBACK* SIO1about)(void);

-typedef void (CALLBACK* SIO1pause)(void);

-typedef void (CALLBACK* SIO1resume)(void);

-typedef long (CALLBACK* SIO1keypressed)(int);

-typedef void (CALLBACK* SIO1writeData8)(unsigned char);

-typedef void (CALLBACK* SIO1writeData16)(unsigned short);

-typedef void (CALLBACK* SIO1writeData32)(unsigned long);

-typedef void (CALLBACK* SIO1writeStat16)(unsigned short);

-typedef void (CALLBACK* SIO1writeStat32)(unsigned long);

-typedef void (CALLBACK* SIO1writeMode16)(unsigned short);

-typedef void (CALLBACK* SIO1writeMode32)(unsigned long);

-typedef void (CALLBACK* SIO1writeCtrl16)(unsigned short);

-typedef void (CALLBACK* SIO1writeCtrl32)(unsigned long);

-typedef void (CALLBACK* SIO1writeBaud16)(unsigned short);

-typedef void (CALLBACK* SIO1writeBaud32)(unsigned long);

-typedef unsigned char (CALLBACK* SIO1readData8)(void);

-typedef unsigned short (CALLBACK* SIO1readData16)(void);

-typedef unsigned long (CALLBACK* SIO1readData32)(void);

-typedef unsigned short (CALLBACK* SIO1readStat16)(void);

-typedef unsigned long (CALLBACK* SIO1readStat32)(void);

-typedef unsigned short (CALLBACK* SIO1readMode16)(void);

-typedef unsigned long (CALLBACK* SIO1readMode32)(void);

-typedef unsigned short (CALLBACK* SIO1readCtrl16)(void);

-typedef unsigned long (CALLBACK* SIO1readCtrl32)(void);

-typedef unsigned short (CALLBACK* SIO1readBaud16)(void);

-typedef unsigned long (CALLBACK* SIO1readBaud32)(void);

-typedef void (CALLBACK* SIO1registerCallback)(void (CALLBACK *callback)(void));

-

-// SIO1 function pointers

-extern SIO1init               SIO1_init;

-extern SIO1shutdown           SIO1_shutdown;

-extern SIO1open               SIO1_open;

-extern SIO1close              SIO1_close;

-extern SIO1test               SIO1_test;

-extern SIO1configure          SIO1_configure;

-extern SIO1about              SIO1_about;

-extern SIO1pause              SIO1_pause;

-extern SIO1resume             SIO1_resume;

-extern SIO1keypressed         SIO1_keypressed;

-extern SIO1writeData8         SIO1_writeData8;

-extern SIO1writeData16        SIO1_writeData16;

-extern SIO1writeData32        SIO1_writeData32;

-extern SIO1writeStat16        SIO1_writeStat16;

-extern SIO1writeStat32        SIO1_writeStat32;

-extern SIO1writeMode16        SIO1_writeMode16;

-extern SIO1writeMode32        SIO1_writeMode32;

-extern SIO1writeCtrl16        SIO1_writeCtrl16;

-extern SIO1writeCtrl32        SIO1_writeCtrl32;

-extern SIO1writeBaud16        SIO1_writeBaud16;

-extern SIO1writeBaud32        SIO1_writeBaud32;

-extern SIO1readData8          SIO1_readData8;

-extern SIO1readData16         SIO1_readData16;

-extern SIO1readData32         SIO1_readData32;

-extern SIO1readStat16         SIO1_readStat16;

-extern SIO1readStat32         SIO1_readStat32;

-extern SIO1readMode16         SIO1_readMode16;

-extern SIO1readMode32         SIO1_readMode32;

-extern SIO1readCtrl16         SIO1_readCtrl16;

-extern SIO1readCtrl32         SIO1_readCtrl32;

-extern SIO1readBaud16         SIO1_readBaud16;

-extern SIO1readBaud32         SIO1_readBaud32;

-extern SIO1registerCallback   SIO1_registerCallback;

-

-#endif

-

-void CALLBACK clearDynarec(void);

-

-void CALLBACK GPUbusy( int ticks );

-

-void SetIsoFile(const char *filename);

-const char *GetIsoFile(void);

-boolean UsingIso(void);

-void SetCdOpenCaseTime(s64 time);

-

-#ifdef __cplusplus

-}

-#endif

-#endif

+/***************************************************************************
+ *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, 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.           *
+ ***************************************************************************/
+
+#ifndef __PLUGINS_H__
+#define __PLUGINS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "psxcommon.h"
+
+#include "plugin_common.h"
+
+#define PLUGINEXTERN typedef
+#define PLUGINCALL(x) (CALLBACK* x)
+
+#include "psemu_plugin_defs.h"
+
+#include "spu.h"
+
+int LoadPlugins();
+void ReleasePlugins();
+int OpenPlugins();
+void ClosePlugins();
+
+// GPU function pointers
+extern GPUupdateLace    GPU_updateLace;
+extern GPUinit          GPU_init;
+extern GPUshutdown      GPU_shutdown;
+extern GPUconfigure     GPU_configure;
+extern GPUtest          GPU_test;
+extern GPUabout         GPU_about;
+extern GPUopen          GPU_open;
+extern GPUclose         GPU_close;
+extern GPUreadStatus    GPU_readStatus;
+extern GPUreadData      GPU_readData;
+extern GPUreadDataMem   GPU_readDataMem;
+extern GPUwriteStatus   GPU_writeStatus;
+extern GPUwriteData     GPU_writeData;
+extern GPUwriteDataMem  GPU_writeDataMem;
+extern GPUdmaChain      GPU_dmaChain;
+extern GPUkeypressed    GPU_keypressed;
+extern GPUdisplayText   GPU_displayText;
+extern GPUmakeSnapshot  GPU_makeSnapshot;
+extern GPUfreeze        GPU_freeze;
+extern GPUgetScreenPic  GPU_getScreenPic;
+extern GPUshowScreenPic GPU_showScreenPic;
+extern GPUclearDynarec  GPU_clearDynarec;
+extern GPUvBlank        GPU_vBlank;
+extern GPUregisterCallback GPU_registerCallback;
+extern GPUidle          GPU_idle;
+extern GPUvisualVibration GPU_visualVibration;
+extern GPUcursor        GPU_cursor;
+
+// CD-ROM function pointers
+extern CDRinit               CDR_init;
+extern CDRshutdown           CDR_shutdown;
+extern CDRopen               CDR_open;
+extern CDRclose              CDR_close;
+extern CDRtest               CDR_test;
+extern CDRgetTN              CDR_getTN;
+extern CDRgetTD              CDR_getTD;
+extern CDRreadTrack          CDR_readTrack;
+extern CDRgetBuffer          CDR_getBuffer;
+extern CDRgetBufferSub       CDR_getBufferSub;
+extern CDRplay               CDR_play;
+extern CDRstop               CDR_stop;
+extern CDRgetStatus          CDR_getStatus;
+extern CDRgetDriveLetter     CDR_getDriveLetter;
+extern CDRconfigure          CDR_configure;
+extern CDRabout              CDR_about;
+extern CDRsetfilename        CDR_setfilename;
+extern CDRreadCDDA           CDR_readCDDA;
+extern CDRgetTE              CDR_getTE;
+
+// SPU function pointers
+extern SPUconfigure        SPU_configure;
+extern SPUabout            SPU_about;
+extern SPUinit             SPU_init;
+extern SPUshutdown         SPU_shutdown;
+extern SPUtest             SPU_test;
+extern SPUopen             SPU_open;
+extern SPUclose            SPU_close;
+extern SPUplaySample       SPU_playSample;
+extern SPUwriteRegister    SPU_writeRegister;
+extern SPUreadRegister     SPU_readRegister;
+extern SPUwriteDMA         SPU_writeDMA;
+extern SPUreadDMA          SPU_readDMA;
+extern SPUwriteDMAMem      SPU_writeDMAMem;
+extern SPUreadDMAMem       SPU_readDMAMem;
+extern SPUplayADPCMchannel SPU_playADPCMchannel;
+extern SPUfreeze           SPU_freeze;
+extern SPUregisterCallback SPU_registerCallback;
+extern SPUasync            SPU_async;
+extern SPUplayCDDAchannel  SPU_playCDDAchannel;
+
+// PAD function pointers
+extern PADconfigure        PAD1_configure;
+extern PADabout            PAD1_about;
+extern PADinit             PAD1_init;
+extern PADshutdown         PAD1_shutdown;
+extern PADtest             PAD1_test;
+extern PADopen             PAD1_open;
+extern PADclose            PAD1_close;
+extern PADquery            PAD1_query;
+extern PADreadPort1        PAD1_readPort1;
+extern PADkeypressed       PAD1_keypressed;
+extern PADstartPoll        PAD1_startPoll;
+extern PADpoll             PAD1_poll;
+extern PADsetSensitive     PAD1_setSensitive;
+extern PADregisterVibration PAD1_registerVibration;
+extern PADregisterCursor   PAD1_registerCursor;
+extern PADconfigure        PAD2_configure;
+extern PADabout            PAD2_about;
+extern PADinit             PAD2_init;
+extern PADshutdown         PAD2_shutdown;
+extern PADtest             PAD2_test;
+extern PADopen             PAD2_open;
+extern PADclose            PAD2_close;
+extern PADquery            PAD2_query;
+extern PADreadPort2        PAD2_readPort2;
+extern PADkeypressed       PAD2_keypressed;
+extern PADstartPoll        PAD2_startPoll;
+extern PADpoll             PAD2_poll;
+extern PADsetSensitive     PAD2_setSensitive;
+extern PADregisterVibration PAD2_registerVibration;
+extern PADregisterCursor   PAD2_registerCursor;
+
+// NET function pointers
+extern NETinit               NET_init;
+extern NETshutdown           NET_shutdown;
+extern NETopen               NET_open;
+extern NETclose              NET_close;
+extern NETtest               NET_test;
+extern NETconfigure          NET_configure;
+extern NETabout              NET_about;
+extern NETpause              NET_pause;
+extern NETresume             NET_resume;
+extern NETqueryPlayer        NET_queryPlayer;
+extern NETsendData           NET_sendData;
+extern NETrecvData           NET_recvData;
+extern NETsendPadData        NET_sendPadData;
+extern NETrecvPadData        NET_recvPadData;
+extern NETsetInfo            NET_setInfo;
+extern NETkeypressed         NET_keypressed;
+
+#ifdef ENABLE_SIO1API
+
+// SIO1 function pointers
+extern SIO1init               SIO1_init;
+extern SIO1shutdown           SIO1_shutdown;
+extern SIO1open               SIO1_open;
+extern SIO1close              SIO1_close;
+extern SIO1test               SIO1_test;
+extern SIO1configure          SIO1_configure;
+extern SIO1about              SIO1_about;
+extern SIO1pause              SIO1_pause;
+extern SIO1resume             SIO1_resume;
+extern SIO1keypressed         SIO1_keypressed;
+extern SIO1writeData8         SIO1_writeData8;
+extern SIO1writeData16        SIO1_writeData16;
+extern SIO1writeData32        SIO1_writeData32;
+extern SIO1writeStat16        SIO1_writeStat16;
+extern SIO1writeStat32        SIO1_writeStat32;
+extern SIO1writeMode16        SIO1_writeMode16;
+extern SIO1writeMode32        SIO1_writeMode32;
+extern SIO1writeCtrl16        SIO1_writeCtrl16;
+extern SIO1writeCtrl32        SIO1_writeCtrl32;
+extern SIO1writeBaud16        SIO1_writeBaud16;
+extern SIO1writeBaud32        SIO1_writeBaud32;
+extern SIO1readData8          SIO1_readData8;
+extern SIO1readData16         SIO1_readData16;
+extern SIO1readData32         SIO1_readData32;
+extern SIO1readStat16         SIO1_readStat16;
+extern SIO1readStat32         SIO1_readStat32;
+extern SIO1readMode16         SIO1_readMode16;
+extern SIO1readMode32         SIO1_readMode32;
+extern SIO1readCtrl16         SIO1_readCtrl16;
+extern SIO1readCtrl32         SIO1_readCtrl32;
+extern SIO1readBaud16         SIO1_readBaud16;
+extern SIO1readBaud32         SIO1_readBaud32;
+extern SIO1registerCallback   SIO1_registerCallback;
+
+#endif
+
+void CALLBACK clearDynarec(void);
+
+void CALLBACK GPUbusy( int ticks );
+
+void SetIsoFile(const char *filename);
+const char *GetIsoFile(void);
+boolean UsingIso(void);
+void SetCdOpenCaseTime(s64 time);
+
+char* CALLBACK CDR__getDriveLetter(void);
+long CALLBACK CDR__configure(void);
+long CALLBACK CDR__test(void);
+void CALLBACK CDR__about(void);
+long CALLBACK CDR__setfilename(char *filename);
+long CALLBACK CDR__getStatus(struct CdrStat *stat);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/libpcsxcore/ppc/pR3000A.c b/libpcsxcore/ppc/pR3000A.c
index 1d6e3de7..da370e43 100644
--- a/libpcsxcore/ppc/pR3000A.c
+++ b/libpcsxcore/ppc/pR3000A.c
@@ -2130,9 +2130,7 @@ REC_FUNC(LWL);
 REC_FUNC(LWR);
 REC_FUNC(SWL);
 REC_FUNC(SWR);
-/*extern u32 LWL_MASK[4];
-extern u32 LWL_SHIFT[4];
-
+/*
 void iLWLk(u32 shift) {
 	if (IsConst(_Rt_)) {
 		MOV32ItoR(ECX, iRegs[_Rt_].k);
@@ -2279,9 +2277,6 @@ static void recLWBlock(int count) {
 	resp = respsave;
 }
 
-extern u32 LWR_MASK[4];
-extern u32 LWR_SHIFT[4];
-
 void iLWRk(u32 shift) {
 	if (IsConst(_Rt_)) {
 		MOV32ItoR(ECX, iRegs[_Rt_].k);
@@ -2580,9 +2575,6 @@ static void recSWBlock(int count) {
 	resp = respsave;
 }
 
-extern u32 SWL_MASK[4];
-extern u32 SWL_SHIFT[4];
-
 void iSWLk(u32 shift) {
 	if (IsConst(_Rt_)) {
 		MOV32ItoR(ECX, iRegs[_Rt_].k);
@@ -2659,9 +2651,6 @@ void recSWL() {
 	resp+= 8;
 }
 
-extern u32 SWR_MASK[4];
-extern u32 SWR_SHIFT[4];
-
 void iSWRk(u32 shift) {
 	if (IsConst(_Rt_)) {
 		MOV32ItoR(ECX, iRegs[_Rt_].k);
diff --git a/libpcsxcore/ppf.c b/libpcsxcore/ppf.c
index 44414a6c..59f4526f 100644
--- a/libpcsxcore/ppf.c
+++ b/libpcsxcore/ppf.c
@@ -210,10 +210,8 @@ void BuildPPFCache() {
 	ppffile = fopen(szPPF, "rb");
 	if (ppffile == NULL) return;
 
-	memset(buffer, 0, 5);
-	fread(buffer, 3, 1, ppffile);
-
-	if (strcmp(buffer, "PPF") != 0) {
+	if (fread(buffer, 3, 1, ppffile) != 1 ||
+	    strcmp(buffer, "PPF") != 0) {
 		SysPrintf(_("Invalid PPF patch: %s.\n"), szPPF);
 		fclose(ppffile);
 		return;
@@ -233,13 +231,21 @@ void BuildPPFCache() {
 		case 1: // ppf2
 			fseek(ppffile, -8, SEEK_END);
 
-			memset(buffer, 0, 5);
-			fread(buffer, 4, 1, ppffile);
+			if(fread(buffer, 4, 1, ppffile) != 1) {
+				SysPrintf(_("Invalid PPF patch: %s.\n"), szPPF);
+				fclose(ppffile);
+				return;
+			}
 
 			if (strcmp(".DIZ", buffer) != 0) {
 				dizyn = 0;
 			} else {
-				fread(&dizlen, 4, 1, ppffile);
+				if(fread(&dizlen, 4, 1, ppffile) != 1) {
+					SysPrintf(_("Invalid PPF patch: %s.\n"), szPPF);
+					fclose(ppffile);
+					return;
+				}
+
 				dizlen = SWAP32(dizlen);
 				dizyn = 1;
 			}
@@ -265,12 +271,20 @@ void BuildPPFCache() {
 
 			fseek(ppffile, -6, SEEK_END);
 			memset(buffer, 0, 5);
-			fread(buffer, 4, 1, ppffile);
+			if(fread(buffer, 4, 1, ppffile) != 1) {
+				SysPrintf(_("Invalid PPF patch: %s.\n"), szPPF);
+				fclose(ppffile);
+				return;
+			}
 			dizlen = 0;
 
 			if (strcmp(".DIZ", buffer) == 0) {
 				fseek(ppffile, -2, SEEK_END);
-				fread(&dizlen, 2, 1, ppffile);
+				if(fread(&dizlen, 4, 1, ppffile) != 1) {
+					SysPrintf(_("Invalid PPF patch: %s.\n"), szPPF);
+					fclose(ppffile);
+					return;
+				}
 				dizlen = SWAP32(dizlen);
 				dizlen += 36;
 			}
@@ -297,13 +311,21 @@ void BuildPPFCache() {
 	// now do the data reading
 	do {                                                
 		fseek(ppffile, seekpos, SEEK_SET);
-		fread(&pos, 4, 1, ppffile);
+		if(fread(&pos, 4, 1, ppffile) != 1) {
+			SysPrintf(_("Invalid PPF patch: %s.\n"), szPPF);
+			fclose(ppffile);
+			return;
+		}
 		pos = SWAP32(pos);
 
-		if (method == 2) fread(buffer, 4, 1, ppffile); // skip 4 bytes on ppf3 (no int64 support here)
+		if (method == 2) fseek(ppffile, 4, SEEK_CUR); // skip 4 bytes on ppf3 (no int64 support here)
 
 		anz = fgetc(ppffile);
-		fread(ppfmem, anz, 1, ppffile);   
+		if(fread(ppfmem, anz, 1, ppffile) != 1) {
+			SysPrintf(_("Invalid PPF patch: %s.\n"), szPPF);
+			fclose(ppffile);
+			return;
+		}
 
 		ladr = pos / CD_FRAMESIZE_RAW;
 		off = pos % CD_FRAMESIZE_RAW;
@@ -366,10 +388,15 @@ void LoadSBI() {
 	if (sbihandle == NULL) return;
 
 	// 4-byte SBI header
-	fread(buffer, 1, 4, sbihandle);
+	if(fread(buffer, 4, 1, sbihandle) != 1) {
+		fclose(sbihandle);
+		return;
+	}
 	while (!feof(sbihandle)) {
-		fread(sbitime[sbicount++], 1, 3, sbihandle);
-		fread(buffer, 1, 11, sbihandle);
+		if(fread(sbitime[sbicount], 3, 1, sbihandle) != 1 ||
+		   fread(buffer, 11, 1, sbihandle) != 1)
+			break;
+		sbicount++;
 	}
 
 	fclose(sbihandle);
diff --git a/libpcsxcore/psemu_plugin_defs.h b/libpcsxcore/psemu_plugin_defs.h
index d1b05ac3..44cebf49 100644
--- a/libpcsxcore/psemu_plugin_defs.h
+++ b/libpcsxcore/psemu_plugin_defs.h
@@ -1,6 +1,12 @@
 #ifndef _PSEMU_PLUGIN_DEFS_H
 #define _PSEMU_PLUGIN_DEFS_H
 
+#include <stdint.h>
+
+#include "psxcommon.h"
+
+#include "plugin_common.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -10,6 +16,13 @@ extern "C" {
 
 #define PLUGIN_VERSION				1
 
+#ifndef PLUGINCALL
+#define PLUGINCALL(x) CALLBACK x
+#endif
+#ifndef PLUGINEXTERN
+#define PLUGINEXTERN
+#endif
+
 // plugin type returned by PSEgetLibType (types can be merged if plugin is multi type!)
 #define PSE_LT_CDR					1
 #define PSE_LT_GPU					2
@@ -17,6 +30,10 @@ extern "C" {
 #define PSE_LT_PAD					8
 #define PSE_LT_NET					16
 
+PLUGINEXTERN unsigned long PLUGINCALL(PSEgetLibType)(void);
+PLUGINEXTERN unsigned long PLUGINCALL(PSEgetLibVersion)(void);
+PLUGINEXTERN char *PLUGINCALL(PSEgetLibName)(void);
+
 // DLL function return codes
 #define PSE_ERR_SUCCESS				0	// every function in DLL if completed sucessfully should return this value
 #define PSE_ERR_FATAL				-1	// undefined error but fatal one, that kills all functionality
@@ -29,6 +46,24 @@ extern "C" {
 #define PSE_INIT_ERR_NOTCONFIGURED	-2	// this driver is not configured
 #define PSE_INIT_ERR_NOHARDWARE		-3	// this driver can not operate properly on this hardware or hardware is not detected
 
+#ifndef _WIN32
+
+PLUGINEXTERN long PLUGINCALL(GPUopen)(unsigned long *, char *, char *);
+PLUGINEXTERN long PLUGINCALL(SPUopen)(void);
+PLUGINEXTERN long PLUGINCALL(PADopen)(unsigned long *);
+PLUGINEXTERN long PLUGINCALL(NETopen)(unsigned long *);
+PLUGINEXTERN long PLUGINCALL(SIO1open)(unsigned long *);
+
+#else
+
+PLUGINEXTERN long PLUGINCALL(GPUopen)(HWND);
+PLUGINEXTERN long PLUGINCALL(SPUopen)(HWND);
+PLUGINEXTERN long PLUGINCALL(PADopen)(HWND);
+PLUGINEXTERN long PLUGINCALL(NETopen)(HWND);
+PLUGINEXTERN long PLUGINCALL(SIO1open)(HWND);
+
+#endif
+
 /*         GPU PlugIn          */
 
 //  GPU_Test return values
@@ -70,6 +105,34 @@ typedef struct
 
 //  GPU_Query	End	- will be implemented in v2
 
+// GPU Functions
+PLUGINEXTERN long PLUGINCALL(GPUinit)(void);
+PLUGINEXTERN long PLUGINCALL(GPUshutdown)(void);
+PLUGINEXTERN long PLUGINCALL(GPUclose)(void);
+PLUGINEXTERN void PLUGINCALL(GPUwriteStatus)(uint32_t);
+PLUGINEXTERN void PLUGINCALL(GPUwriteData)(uint32_t);
+PLUGINEXTERN void PLUGINCALL(GPUwriteDataMem)(uint32_t *, int);
+PLUGINEXTERN uint32_t PLUGINCALL(GPUreadStatus)(void);
+PLUGINEXTERN uint32_t PLUGINCALL(GPUreadData)(void);
+PLUGINEXTERN void PLUGINCALL(GPUreadDataMem)(uint32_t *, int);
+PLUGINEXTERN long PLUGINCALL(GPUdmaChain)(uint32_t *,uint32_t);
+PLUGINEXTERN void PLUGINCALL(GPUupdateLace)(void);
+PLUGINEXTERN long PLUGINCALL(GPUconfigure)(void);
+PLUGINEXTERN long PLUGINCALL(GPUtest)(void);
+PLUGINEXTERN void PLUGINCALL(GPUabout)(void);
+PLUGINEXTERN void PLUGINCALL(GPUmakeSnapshot)(void);
+PLUGINEXTERN void PLUGINCALL(GPUkeypressed)(int);
+PLUGINEXTERN void PLUGINCALL(GPUdisplayText)(char *);
+PLUGINEXTERN long PLUGINCALL(GPUfreeze)(uint32_t, GPUFreeze_t *);
+PLUGINEXTERN long PLUGINCALL(GPUgetScreenPic)(unsigned char *);
+PLUGINEXTERN long PLUGINCALL(GPUshowScreenPic)(unsigned char *);
+PLUGINEXTERN void PLUGINCALL(GPUclearDynarec)(void (CALLBACK *callback)(void));
+PLUGINEXTERN void PLUGINCALL(GPUvBlank)(int);
+PLUGINEXTERN void PLUGINCALL(GPUregisterCallback)(void (CALLBACK *callback)(int));
+PLUGINEXTERN void PLUGINCALL(GPUidle)(void);
+PLUGINEXTERN void PLUGINCALL(GPUvisualVibration)(uint32_t, uint32_t);
+PLUGINEXTERN void PLUGINCALL(GPUcursor)(int, int, int);
+
 
 /*         CDR PlugIn          */
 
@@ -94,6 +157,26 @@ typedef struct
 // this might happen to CDROMS that do not support RAW mode reading - surelly it will kill many games
 #define PSE_CDR_WARN_LAMECD			PSE_CDR_WARN + 0
 
+// CD-ROM Functions
+PLUGINEXTERN long PLUGINCALL(CDRinit)(void);
+PLUGINEXTERN long PLUGINCALL(CDRshutdown)(void);
+PLUGINEXTERN long PLUGINCALL(CDRopen)(void);
+PLUGINEXTERN long PLUGINCALL(CDRclose)(void);
+PLUGINEXTERN long PLUGINCALL(CDRgetTN)(unsigned char *);
+PLUGINEXTERN long PLUGINCALL(CDRgetTD)(unsigned char, unsigned char *);
+PLUGINEXTERN long PLUGINCALL(CDRreadTrack)(unsigned char *);
+PLUGINEXTERN unsigned char* PLUGINCALL(CDRgetBuffer)(void);
+PLUGINEXTERN unsigned char* PLUGINCALL(CDRgetBufferSub)(void);
+PLUGINEXTERN long PLUGINCALL(CDRconfigure)(void);
+PLUGINEXTERN long PLUGINCALL(CDRtest)(void);
+PLUGINEXTERN void PLUGINCALL(CDRabout)(void);
+PLUGINEXTERN long PLUGINCALL(CDRplay)(unsigned char *);
+PLUGINEXTERN long PLUGINCALL(CDRstop)(void);
+PLUGINEXTERN long PLUGINCALL(CDRsetfilename)(char *);
+PLUGINEXTERN long PLUGINCALL(CDRgetStatus)(struct CdrStat *);
+PLUGINEXTERN char* PLUGINCALL(CDRgetDriveLetter)(void);
+PLUGINEXTERN long PLUGINCALL(CDRreadCDDA)(unsigned char, unsigned char, unsigned char, unsigned char *);
+PLUGINEXTERN long PLUGINCALL(CDRgetTE)(unsigned char, unsigned char *, unsigned char *, unsigned char *);
 
 
 
@@ -119,6 +202,25 @@ typedef struct
 #define PSE_SPU_WARN				60
 
 
+// SPU Functions
+PLUGINEXTERN long PLUGINCALL(SPUinit)(void);
+PLUGINEXTERN long PLUGINCALL(SPUshutdown)(void);
+PLUGINEXTERN long PLUGINCALL(SPUclose)(void);
+PLUGINEXTERN void PLUGINCALL(SPUplaySample)(unsigned char);
+PLUGINEXTERN void PLUGINCALL(SPUwriteRegister)(unsigned long, unsigned short);
+PLUGINEXTERN unsigned short PLUGINCALL(SPUreadRegister)(unsigned long);
+PLUGINEXTERN void PLUGINCALL(SPUwriteDMA)(unsigned short);
+PLUGINEXTERN unsigned short PLUGINCALL(SPUreadDMA)(void);
+PLUGINEXTERN void PLUGINCALL(SPUwriteDMAMem)(unsigned short *, int);
+PLUGINEXTERN void PLUGINCALL(SPUreadDMAMem)(unsigned short *, int);
+PLUGINEXTERN void PLUGINCALL(SPUplayADPCMchannel)(xa_decode_t *);
+PLUGINEXTERN void PLUGINCALL(SPUregisterCallback)(void (CALLBACK *callback)(void));
+PLUGINEXTERN long PLUGINCALL(SPUconfigure)(void);
+PLUGINEXTERN long PLUGINCALL(SPUtest)(void);
+PLUGINEXTERN void PLUGINCALL(SPUabout)(void);
+PLUGINEXTERN long PLUGINCALL(SPUfreeze)(uint32_t, SPUFreeze_t *);
+PLUGINEXTERN void PLUGINCALL(SPUasync)(uint32_t);
+PLUGINEXTERN void PLUGINCALL(SPUplayCDDAchannel)(short *, int);
 
 
 /*         PAD PlugIn          */
@@ -126,6 +228,7 @@ typedef struct
 /*
 
   functions that must be exported from PAD Plugin
+  (see below for actual prototypes)
 
   long	PADinit(long flags);	// called only once when PSEmu Starts
   void	PADshutdown(void);		// called when PSEmu exits
@@ -209,6 +312,24 @@ typedef struct
 
 } PadDataS;
 
+// PAD Functions
+PLUGINEXTERN long PLUGINCALL(PADconfigure)(void);
+PLUGINEXTERN void PLUGINCALL(PADabout)(void);
+PLUGINEXTERN long PLUGINCALL(PADinit)(long);
+PLUGINEXTERN long PLUGINCALL(PADshutdown)(void);
+PLUGINEXTERN long PLUGINCALL(PADtest)(void);
+PLUGINEXTERN long PLUGINCALL(PADclose)(void);
+PLUGINEXTERN long PLUGINCALL(PADquery)(void);
+PLUGINEXTERN long PLUGINCALL(PADreadPort1)(PadDataS*);
+PLUGINEXTERN long PLUGINCALL(PADreadPort2)(PadDataS*);
+PLUGINEXTERN long PLUGINCALL(PADkeypressed)(void);
+PLUGINEXTERN unsigned char PLUGINCALL(PADstartPoll)(int);
+PLUGINEXTERN unsigned char PLUGINCALL(PADpoll)(unsigned char);
+PLUGINEXTERN void PLUGINCALL(PADsetSensitive)(int);
+PLUGINEXTERN void PLUGINCALL(PADregisterVibration)(void (CALLBACK *callback)(uint32_t, uint32_t));
+PLUGINEXTERN void PLUGINCALL(PADregisterCursor)(void (CALLBACK *callback)(int, int, int));
+
+
 /*         NET PlugIn v2       */
 /* Added by linuzappz@pcsx.net */
 
@@ -278,6 +399,60 @@ typedef struct {
    void NETkeypressed(int key) (linux only)
     key is a XK_?? (X11) keycode.
 */
+// NET Functions
+PLUGINEXTERN long PLUGINCALL(NETinit)(void);
+PLUGINEXTERN long PLUGINCALL(NETshutdown)(void);
+PLUGINEXTERN long PLUGINCALL(NETclose)(void);
+PLUGINEXTERN long PLUGINCALL(NETconfigure)(void);
+PLUGINEXTERN long PLUGINCALL(NETtest)(void);
+PLUGINEXTERN void PLUGINCALL(NETabout)(void);
+PLUGINEXTERN void PLUGINCALL(NETpause)(void);
+PLUGINEXTERN void PLUGINCALL(NETresume)(void);
+PLUGINEXTERN long PLUGINCALL(NETqueryPlayer)(void);
+PLUGINEXTERN long PLUGINCALL(NETsendData)(void *, int, int);
+PLUGINEXTERN long PLUGINCALL(NETrecvData)(void *, int, int);
+PLUGINEXTERN long PLUGINCALL(NETsendPadData)(void *, int);
+PLUGINEXTERN long PLUGINCALL(NETrecvPadData)(void *, int);
+PLUGINEXTERN long PLUGINCALL(NETsetInfo)(netInfo *);
+PLUGINEXTERN long PLUGINCALL(NETkeypressed)(int);
+
+#ifdef ENABLE_SIO1API
+
+// SIO1 Functions (link cable)
+PLUGINEXTERN long PLUGINCALL(SIO1init)(void);
+PLUGINEXTERN long PLUGINCALL(SIO1shutdown)(void);
+PLUGINEXTERN long PLUGINCALL(SIO1close)(void);
+PLUGINEXTERN long PLUGINCALL(SIO1configure)(void);
+PLUGINEXTERN long PLUGINCALL(SIO1test)(void);
+PLUGINEXTERN void PLUGINCALL(SIO1about)(void);
+PLUGINEXTERN void PLUGINCALL(SIO1pause)(void);
+PLUGINEXTERN void PLUGINCALL(SIO1resume)(void);
+PLUGINEXTERN long PLUGINCALL(SIO1keypressed)(int);
+PLUGINEXTERN void PLUGINCALL(SIO1writeData8)(unsigned char);
+PLUGINEXTERN void PLUGINCALL(SIO1writeData16)(unsigned short);
+PLUGINEXTERN void PLUGINCALL(SIO1writeData32)(unsigned long);
+PLUGINEXTERN void PLUGINCALL(SIO1writeStat16)(unsigned short);
+PLUGINEXTERN void PLUGINCALL(SIO1writeStat32)(unsigned long);
+PLUGINEXTERN void PLUGINCALL(SIO1writeMode16)(unsigned short);
+PLUGINEXTERN void PLUGINCALL(SIO1writeMode32)(unsigned long);
+PLUGINEXTERN void PLUGINCALL(SIO1writeCtrl16)(unsigned short);
+PLUGINEXTERN void PLUGINCALL(SIO1writeCtrl32)(unsigned long);
+PLUGINEXTERN void PLUGINCALL(SIO1writeBaud16)(unsigned short);
+PLUGINEXTERN void PLUGINCALL(SIO1writeBaud32)(unsigned long);
+PLUGINEXTERN unsigned char PLUGINCALL(SIO1readData8)(void);
+PLUGINEXTERN unsigned short PLUGINCALL(SIO1readData16)(void);
+PLUGINEXTERN unsigned long PLUGINCALL(SIO1readData32)(void);
+PLUGINEXTERN unsigned short PLUGINCALL(SIO1readStat16)(void);
+PLUGINEXTERN unsigned long PLUGINCALL(SIO1readStat32)(void);
+PLUGINEXTERN unsigned short PLUGINCALL(SIO1readMode16)(void);
+PLUGINEXTERN unsigned long PLUGINCALL(SIO1readMode32)(void);
+PLUGINEXTERN unsigned short PLUGINCALL(SIO1readCtrl16)(void);
+PLUGINEXTERN unsigned long PLUGINCALL(SIO1readCtrl32)(void);
+PLUGINEXTERN unsigned short PLUGINCALL(SIO1readBaud16)(void);
+PLUGINEXTERN unsigned long PLUGINCALL(SIO1readBaud32)(void);
+PLUGINEXTERN void PLUGINCALL(SIO1registerCallback)(void (CALLBACK *callback)(void));
+
+#endif
 
 #ifdef __cplusplus
 }
diff --git a/libpcsxcore/psxbios.c b/libpcsxcore/psxbios.c
index 68163d5a..277f33a9 100644
--- a/libpcsxcore/psxbios.c
+++ b/libpcsxcore/psxbios.c
@@ -72,7 +72,7 @@ char *biosA0n[256] = {
 	"sys_a0_8c",		"sys_a0_8d",	"sys_a0_8e",		"sys_a0_8f",
 // 0x90
 	"sys_a0_90",		"sys_a0_91",	"sys_a0_92",		"sys_a0_93",
-	"sys_a0_94",		"sys_a0_95",	"AddCDROMDevice",	"AddMemCardDevide",
+	"sys_a0_94",		"sys_a0_95",	"AddCDROMDevice",	"AddMemCardDevice",
 	"DisableKernelIORedirection",		"EnableKernelIORedirection", "sys_a0_9a", "sys_a0_9b",
 	"SetConf",			"GetConf",		"sys_a0_9e",		"SetMem",
 // 0xa0
@@ -93,7 +93,7 @@ char *biosB0n[256] = {
 	"EnableEvent",		"DisableEvent",	"OpenTh",		"CloseTh",
 // 0x10
 	"ChangeTh",			"sys_b0_11",	"InitPAD",		"StartPAD",
-	"StopPAD",			"PAD_init",		"PAD_dr",		"ReturnFromExecption",
+	"StopPAD",			"PAD_init",		"PAD_dr",		"ReturnFromException",
 	"ResetEntryInt",	"HookEntryInt",	"sys_b0_1a",	"sys_b0_1b",
 	"sys_b0_1c",		"sys_b0_1d",	"sys_b0_1e",	"sys_b0_1f",
 // 0x20
@@ -310,17 +310,17 @@ static inline void LoadRegs() {
 //               System calls A0             */
 
 
-void psxBios_abs() { // 0x0e
+static void psxBios_abs() { // 0x0e
 	if ((s32)a0 < 0) v0 = -(s32)a0;
 	else v0 = a0;
 	pc0 = ra;
 }
 
-void psxBios_labs() { // 0x0f
+static void psxBios_labs() { // 0x0f
 	psxBios_abs();
 }
 
-void psxBios_atoi() { // 0x10
+static void psxBios_atoi() { // 0x10
 	s32 n = 0, f = 0;
 	char *p = (char *)Ra0;
 
@@ -341,11 +341,11 @@ void psxBios_atoi() { // 0x10
 	pc0 = ra;
 }
 
-void psxBios_atol() { // 0x11
+static void psxBios_atol() { // 0x11
 	psxBios_atoi();
 }
 
-void psxBios_setjmp() { // 0x13
+static void psxBios_setjmp() { // 0x13
 	u32 *jmp_buf = (u32 *)Ra0;
 	int i;
 
@@ -363,7 +363,7 @@ void psxBios_setjmp() { // 0x13
 	v0 = 0; pc0 = ra;
 }
 
-void psxBios_longjmp() { // 0x14
+static void psxBios_longjmp() { // 0x14
 	u32 *jmp_buf = (u32 *)Ra0;
 	int i;
 
@@ -381,7 +381,7 @@ void psxBios_longjmp() { // 0x14
 	v0 = a1; pc0 = ra;
 }
 
-void psxBios_strcat() { // 0x15
+static void psxBios_strcat() { // 0x15
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 
 #ifdef PSXBIOS_LOG
@@ -395,7 +395,7 @@ void psxBios_strcat() { // 0x15
 	v0 = a0; pc0 = ra;
 }
 
-void psxBios_strncat() { // 0x16
+static void psxBios_strncat() { // 0x16
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 	s32 n = a2;
 
@@ -415,7 +415,7 @@ void psxBios_strncat() { // 0x16
 	v0 = a0; pc0 = ra;
 }
 
-void psxBios_strcmp() { // 0x17
+static void psxBios_strcmp() { // 0x17
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 
 #ifdef PSXBIOS_LOG
@@ -434,7 +434,7 @@ void psxBios_strcmp() { // 0x17
 	pc0 = ra;
 }
 
-void psxBios_strncmp() { // 0x18
+static void psxBios_strncmp() { // 0x18
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 	s32 n = a2;
 
@@ -454,14 +454,14 @@ void psxBios_strncmp() { // 0x18
 	pc0 = ra;
 }
 
-void psxBios_strcpy() { // 0x19
+static void psxBios_strcpy() { // 0x19
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 	while ((*p1++ = *p2++) != '\0');
 
 	v0 = a0; pc0 = ra;
 }
 
-void psxBios_strncpy() { // 0x1a
+static void psxBios_strncpy() { // 0x1a
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 	s32 n = a2, i;
 
@@ -478,14 +478,14 @@ void psxBios_strncpy() { // 0x1a
 	v0 = a0; pc0 = ra;
 }
 
-void psxBios_strlen() { // 0x1b
+static void psxBios_strlen() { // 0x1b
 	char *p = (char *)Ra0;
 	v0 = 0;
 	while (*p++) v0++;
 	pc0 = ra;
 }
 
-void psxBios_index() { // 0x1c
+static void psxBios_index() { // 0x1c
 	char *p = (char *)Ra0;
 
 	do {
@@ -499,7 +499,7 @@ void psxBios_index() { // 0x1c
 	v0 = 0; pc0 = ra;
 }
 
-void psxBios_rindex() { // 0x1d
+static void psxBios_rindex() { // 0x1d
 	char *p = (char *)Ra0;
 
 	v0 = 0;
@@ -512,15 +512,15 @@ void psxBios_rindex() { // 0x1d
 	pc0 = ra;
 }
 
-void psxBios_strchr() { // 0x1e
+static void psxBios_strchr() { // 0x1e
 	psxBios_index();
 }
 
-void psxBios_strrchr() { // 0x1f
+static void psxBios_strrchr() { // 0x1f
 	psxBios_rindex();
 }
 
-void psxBios_strpbrk() { // 0x20
+static void psxBios_strpbrk() { // 0x20
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1, *scanp, c, sc;
 
 	while ((c = *p1++) != '\0') {
@@ -537,7 +537,7 @@ void psxBios_strpbrk() { // 0x20
 	v0 = a0; pc0 = ra;
 }
 
-void psxBios_strspn() { // 0x21
+static void psxBios_strspn() { // 0x21
 	char *p1, *p2;
 
 	for (p1 = (char *)Ra0; *p1 != '\0'; p1++) {
@@ -548,7 +548,7 @@ void psxBios_strspn() { // 0x21
 	v0 = p1 - (char *)Ra0; pc0 = ra;
 }
 
-void psxBios_strcspn() { // 0x22
+static void psxBios_strcspn() { // 0x22
 	char *p1, *p2;
 
 	for (p1 = (char *)Ra0; *p1 != '\0'; p1++) {
@@ -559,7 +559,7 @@ void psxBios_strcspn() { // 0x22
 	v0 = p1 - (char *)Ra0; pc0 = ra;
 }
 
-void psxBios_strtok() { // 0x23
+static void psxBios_strtok() { // 0x23
 	char *pcA0 = (char *)Ra0;
 	char *pcRet = strtok(pcA0, (char *)Ra1);
 	if (pcRet)
@@ -569,7 +569,7 @@ void psxBios_strtok() { // 0x23
 	pc0 = ra;
 }
 
-void psxBios_strstr() { // 0x24
+static void psxBios_strstr() { // 0x24
 	char *p = (char *)Ra0, *p1, *p2;
 
 	while (*p != '\0') {
@@ -592,33 +592,33 @@ void psxBios_strstr() { // 0x24
 	v0 = 0; pc0 = ra;
 }
 
-void psxBios_toupper() { // 0x25
+static void psxBios_toupper() { // 0x25
 	v0 = (s8)(a0 & 0xff);
 	if (v0 >= 'a' && v0 <= 'z') v0 -= 'a' - 'A';
 	pc0 = ra;
 }
 
-void psxBios_tolower() { // 0x26
+static void psxBios_tolower() { // 0x26
 	v0 = (s8)(a0 & 0xff);
 	if (v0 >= 'A' && v0 <= 'Z') v0 += 'a' - 'A';
 	pc0 = ra;
 }
 
-void psxBios_bcopy() { // 0x27
+static void psxBios_bcopy() { // 0x27
 	char *p1 = (char *)Ra1, *p2 = (char *)Ra0;
 	while (a2-- > 0) *p1++ = *p2++;
 
 	pc0 = ra;
 }
 
-void psxBios_bzero() { // 0x28
+static void psxBios_bzero() { // 0x28
 	char *p = (char *)Ra0;
 	while (a1-- > 0) *p++ = '\0';
 
 	pc0 = ra;
 }
 
-void psxBios_bcmp() { // 0x29
+static void psxBios_bcmp() { // 0x29
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 
 	if (a0 == 0 || a1 == 0) { v0 = 0; pc0 = ra; return; }
@@ -634,21 +634,21 @@ void psxBios_bcmp() { // 0x29
 	v0 = 0; pc0 = ra;
 }
 
-void psxBios_memcpy() { // 0x2a
+static void psxBios_memcpy() { // 0x2a
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 	while (a2-- > 0) *p1++ = *p2++;
 
 	v0 = a0; pc0 = ra;
 }
 
-void psxBios_memset() { // 0x2b
+static void psxBios_memset() { // 0x2b
 	char *p = (char *)Ra0;
 	while (a2-- > 0) *p++ = (char)a1;
 
 	v0 = a0; pc0 = ra;
 }
 
-void psxBios_memmove() { // 0x2c
+static void psxBios_memmove() { // 0x2c
 	char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 
 	if (p2 <= p1 && p2 + a2 > p1) {
@@ -663,11 +663,11 @@ void psxBios_memmove() { // 0x2c
 	v0 = a0; pc0 = ra;
 }
 
-void psxBios_memcmp() { // 0x2d
+static void psxBios_memcmp() { // 0x2d
 	psxBios_bcmp();
 }
 
-void psxBios_memchr() { // 0x2e
+static void psxBios_memchr() { // 0x2e
 	char *p = (char *)Ra0;
 
 	while (a2-- > 0) {
@@ -680,14 +680,14 @@ void psxBios_memchr() { // 0x2e
 	v0 = 0; pc0 = ra;
 }
 
-void psxBios_rand() { // 0x2f
+static void psxBios_rand() { // 0x2f
 	u32 s = psxMu32(0x9010) * 1103515245 + 12345;
 	v0 = (s >> 16) & 0x7fff;
 	psxMu32ref(0x9010) = SWAPu32(s);
 	pc0 = ra;
 }
 
-void psxBios_srand() { // 0x30
+static void psxBios_srand() { // 0x30
 	psxMu32ref(0x9010) = SWAPu32(a0);
 	pc0 = ra;
 }
@@ -790,7 +790,7 @@ loop:
 	}
 }
 
-void psxBios_qsort() { // 0x31
+static void psxBios_qsort() { // 0x31
 	qswidth = a2;
 	qscmpfunc = a3;
 	qsort_main((char *)Ra0, (char *)Ra0 + a1 * a2);
@@ -798,9 +798,9 @@ void psxBios_qsort() { // 0x31
 	pc0 = ra;
 }
 
-void psxBios_malloc() { // 0x33
-	unsigned int *chunk, *newchunk;
-	unsigned int dsize, csize, cstat;
+static void psxBios_malloc() { // 0x33
+	unsigned int *chunk, *newchunk = NULL;
+	unsigned int dsize = 0, csize, cstat;
 	int colflag;
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x33]);
@@ -870,7 +870,7 @@ void psxBios_malloc() { // 0x33
 		// split free chunk
 		*chunk = SWAP32(dsize);
 		newchunk = (u32*)((uptr)chunk + dsize + 4);
-		*newchunk = SWAP32((csize - dsize - 4) & 0xfffffffc | 1);
+		*newchunk = SWAP32(((csize - dsize - 4) & 0xfffffffc) | 1);
 	}
 
 	// return pointer to allocated memory
@@ -880,7 +880,7 @@ void psxBios_malloc() { // 0x33
 	pc0 = ra;
 }
 
-void psxBios_free() { // 0x34
+static void psxBios_free() { // 0x34
 
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x34]);
@@ -892,7 +892,7 @@ void psxBios_free() { // 0x34
 	pc0 = ra;
 }
 
-void psxBios_calloc() { // 0x37
+static void psxBios_calloc() { // 0x37
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x37]);
 #endif
@@ -902,7 +902,7 @@ void psxBios_calloc() { // 0x37
 	memset(Rv0, 0, a0);
 }
 
-void psxBios_realloc() { // 0x38
+static void psxBios_realloc() { // 0x38
 	u32 block = a0;
 	u32 size = a1;
 #ifdef PSXBIOS_LOG
@@ -917,7 +917,7 @@ void psxBios_realloc() { // 0x38
 
 
 /* InitHeap(void *block , int n) */
-void psxBios_InitHeap() { // 0x39
+static void psxBios_InitHeap() { // 0x39
 	unsigned int size;
 
 #ifdef PSXBIOS_LOG
@@ -938,11 +938,11 @@ void psxBios_InitHeap() { // 0x39
 	pc0 = ra;
 }
 
-void psxBios_getchar() { //0x3b
+static void psxBios_getchar() { //0x3b
 	v0 = getchar(); pc0 = ra;
 }
 
-void psxBios_printf() { // 0x3f
+static void psxBios_printf() { // 0x3f
 	char tmp[1024];
 	char tmp2[1024];
 	u32 save[4];
@@ -1014,7 +1014,7 @@ _start:
  *	long Load(char *name, struct EXEC *header);
  */
 
-void psxBios_Load() { // 0x42
+static void psxBios_Load() { // 0x42
 	EXE_HEADER eheader;
 
 #ifdef PSXBIOS_LOG
@@ -1033,7 +1033,7 @@ void psxBios_Load() { // 0x42
  *	int Exec(struct EXEC *header , int argc , char **argv);
  */
 
-void psxBios_Exec() { // 43
+static void psxBios_Exec() { // 43
 	EXEC *header = (EXEC*)Ra0;
 	u32 tmp;
 
@@ -1065,17 +1065,17 @@ void psxBios_Exec() { // 43
 	pc0 = header->_pc0;
 }
 
-void psxBios_FlushCache() { // 44
+static void psxBios_FlushCache() { // 44
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x44]);
 #endif
-

-	psxRegs.ICache_valid = 0;

+
+	psxRegs.ICache_valid = 0;
 
 	pc0 = ra;
 }
 
-void psxBios_GPU_dw() { // 0x46
+static void psxBios_GPU_dw() { // 0x46
 	int size;
 	s32 *ptr;
 
@@ -1096,7 +1096,7 @@ void psxBios_GPU_dw() { // 0x46
 	pc0 = ra;
 }  
 
-void psxBios_mem2vram() { // 0x47
+static void psxBios_mem2vram() { // 0x47
 	int size;
 
 	GPU_writeData(0xa0000000);
@@ -1113,17 +1113,17 @@ void psxBios_mem2vram() { // 0x47
 	pc0 = ra;
 }
 
-void psxBios_SendGPU() { // 0x48
+static void psxBios_SendGPU() { // 0x48
 	GPU_writeStatus(a0);
 	pc0 = ra;
 }
 
-void psxBios_GPU_cw() { // 0x49
+static void psxBios_GPU_cw() { // 0x49
 	GPU_writeData(a0);
 	pc0 = ra;
 }
 
-void psxBios_GPU_cwb() { // 0x4a
+static void psxBios_GPU_cwb() { // 0x4a
 	s32 *ptr = (s32*)Ra0;
 	int size = a1;
 	while(size--) {
@@ -1134,7 +1134,7 @@ void psxBios_GPU_cwb() { // 0x4a
 	pc0 = ra;
 }
    
-void psxBios_GPU_SendPackets() { //4b:	
+static void psxBios_GPU_SendPackets() { //4b:	
 	GPU_writeStatus(0x04000002);
 	psxHwWrite32(0x1f8010f4,0);
 	psxHwWrite32(0x1f8010f0,psxHwRead32(0x1f8010f0)|0x800);
@@ -1144,7 +1144,7 @@ void psxBios_GPU_SendPackets() { //4b:
 	pc0 = ra;
 }
 
-void psxBios_sys_a0_4c() { // 0x4c GPU relate
+static void psxBios_sys_a0_4c() { // 0x4c GPU relate
 	psxHwWrite32(0x1f8010a8,0x00000401);
 	GPU_writeData(0x0400000);
 	GPU_writeData(0x0200000);
@@ -1153,14 +1153,14 @@ void psxBios_sys_a0_4c() { // 0x4c GPU relate
 	pc0 = ra;
 }
 
-void psxBios_GPU_GetGPUStatus() { // 0x4d
+static void psxBios_GPU_GetGPUStatus() { // 0x4d
 	v0 = GPU_readStatus();
 	pc0 = ra;
 }
 
 #undef s_addr
 
-void psxBios_LoadExec() { // 51
+static void psxBios_LoadExec() { // 51
 	EXEC *header = (EXEC*)PSXM(0xf000);
 	u32 s_addr, s_size;
 
@@ -1179,7 +1179,7 @@ void psxBios_LoadExec() { // 51
 	psxBios_Exec();
 }
 
-void psxBios__bu_init() { // 70
+static void psxBios__bu_init() { // 70
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x70]);
 #endif
@@ -1190,7 +1190,7 @@ void psxBios__bu_init() { // 70
 	pc0 = ra;
 }
 
-void psxBios__96_init() { // 71
+static void psxBios__96_init() { // 71
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x71]);
 #endif
@@ -1198,7 +1198,7 @@ void psxBios__96_init() { // 71
 	pc0 = ra;
 }
 
-void psxBios__96_remove() { // 72
+static void psxBios__96_remove() { // 72
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x72]);
 #endif
@@ -1206,7 +1206,7 @@ void psxBios__96_remove() { // 72
 	pc0 = ra;
 }
 
-void psxBios_SetMem() { // 9f
+static void psxBios_SetMem() { // 9f
 	u32 new = psxHu32(0x1060);
 
 #ifdef PSXBIOS_LOG
@@ -1233,7 +1233,7 @@ void psxBios_SetMem() { // 9f
 	pc0 = ra;
 }
 
-void psxBios__card_info() { // ab
+static void psxBios__card_info() { // ab
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s: %x\n", biosA0n[0xab], a0);
 #endif
@@ -1246,7 +1246,7 @@ void psxBios__card_info() { // ab
 	v0 = 1; pc0 = ra;
 }
 
-void psxBios__card_load() { // ac
+static void psxBios__card_load() { // ac
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s: %x\n", biosA0n[0xac], a0);
 #endif
@@ -1261,7 +1261,7 @@ void psxBios__card_load() { // ac
 
 /* System calls B0 */
 
-void psxBios_SetRCnt() { // 02
+static void psxBios_SetRCnt() { // 02
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x02]);
 #endif
@@ -1282,7 +1282,7 @@ void psxBios_SetRCnt() { // 02
 	pc0 = ra;
 }
 
-void psxBios_GetRCnt() { // 03
+static void psxBios_GetRCnt() { // 03
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x03]);
 #endif
@@ -1293,7 +1293,7 @@ void psxBios_GetRCnt() { // 03
 	pc0 = ra;
 }
 
-void psxBios_StartRCnt() { // 04
+static void psxBios_StartRCnt() { // 04
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x04]);
 #endif
@@ -1304,7 +1304,7 @@ void psxBios_StartRCnt() { // 04
 	v0 = 1; pc0 = ra;
 }
 
-void psxBios_StopRCnt() { // 05
+static void psxBios_StopRCnt() { // 05
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x05]);
 #endif
@@ -1315,7 +1315,7 @@ void psxBios_StopRCnt() { // 05
 	pc0 = ra;
 }
 
-void psxBios_ResetRCnt() { // 06
+static void psxBios_ResetRCnt() { // 06
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x06]);
 #endif
@@ -1348,7 +1348,7 @@ void psxBios_ResetRCnt() { // 06
 			break; \
 	}
 
-void psxBios_DeliverEvent() { // 07
+static void psxBios_DeliverEvent() { // 07
 	int ev, spec;
 	int i;
 
@@ -1364,7 +1364,7 @@ void psxBios_DeliverEvent() { // 07
 	pc0 = ra;
 }
 
-void psxBios_OpenEvent() { // 08
+static void psxBios_OpenEvent() { // 08
 	int ev, spec;
 	int i;
 
@@ -1383,7 +1383,7 @@ void psxBios_OpenEvent() { // 08
 	pc0 = ra;
 }
 
-void psxBios_CloseEvent() { // 09
+static void psxBios_CloseEvent() { // 09
 	int ev, spec;
 
 	ev   = a0 & 0xff;
@@ -1398,7 +1398,7 @@ void psxBios_CloseEvent() { // 09
 	v0 = 1; pc0 = ra;
 }
 
-void psxBios_WaitEvent() { // 0a
+static void psxBios_WaitEvent() { // 0a
 	int ev, spec;
 
 	ev   = a0 & 0xff;
@@ -1413,7 +1413,7 @@ void psxBios_WaitEvent() { // 0a
 	v0 = 1; pc0 = ra;
 }
 
-void psxBios_TestEvent() { // 0b
+static void psxBios_TestEvent() { // 0b
 	int ev, spec;
 
 	ev   = a0 & 0xff;
@@ -1430,7 +1430,7 @@ void psxBios_TestEvent() { // 0b
 	pc0 = ra;
 }
 
-void psxBios_EnableEvent() { // 0c
+static void psxBios_EnableEvent() { // 0c
 	int ev, spec;
 
 	ev   = a0 & 0xff;
@@ -1445,7 +1445,7 @@ void psxBios_EnableEvent() { // 0c
 	v0 = 1; pc0 = ra;
 }
 
-void psxBios_DisableEvent() { // 0d
+static void psxBios_DisableEvent() { // 0d
 	int ev, spec;
 
 	ev   = a0 & 0xff;
@@ -1464,7 +1464,7 @@ void psxBios_DisableEvent() { // 0d
  *	long OpenTh(long (*func)(), unsigned long sp, unsigned long gp);
  */
 
-void psxBios_OpenTh() { // 0e
+static void psxBios_OpenTh() { // 0e
 	int th;
 
 	for (th=1; th<8; th++)
@@ -1486,7 +1486,7 @@ void psxBios_OpenTh() { // 0e
  *	int CloseTh(long thread);
  */
 
-void psxBios_CloseTh() { // 0f
+static void psxBios_CloseTh() { // 0f
 	int th = a0 & 0xff;
 
 #ifdef PSXBIOS_LOG
@@ -1507,7 +1507,7 @@ void psxBios_CloseTh() { // 0f
  *	int ChangeTh(long thread);
  */
 
-void psxBios_ChangeTh() { // 10
+static void psxBios_ChangeTh() { // 10
 	int th = a0 & 0xff;
 
 #ifdef PSXBIOS_LOG
@@ -1534,7 +1534,7 @@ void psxBios_ChangeTh() { // 10
 	}
 }
 
-void psxBios_InitPAD() { // 0x12
+static void psxBios_InitPAD() { // 0x12
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x12]);
 #endif
@@ -1547,7 +1547,7 @@ void psxBios_InitPAD() { // 0x12
 	v0 = 1; pc0 = ra;
 }
 
-void psxBios_StartPAD() { // 13
+static void psxBios_StartPAD() { // 13
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x13]);
 #endif
@@ -1557,7 +1557,7 @@ void psxBios_StartPAD() { // 13
 	pc0 = ra;
 }
 
-void psxBios_StopPAD() { // 14
+static void psxBios_StopPAD() { // 14
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x14]);
 #endif
@@ -1567,7 +1567,7 @@ void psxBios_StopPAD() { // 14
 	pc0 = ra;
 }
 
-void psxBios_PAD_init() { // 15
+static void psxBios_PAD_init() { // 15
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x15]);
 #endif
@@ -1578,7 +1578,7 @@ void psxBios_PAD_init() { // 15
 	pc0 = ra;
 }
 
-void psxBios_PAD_dr() { // 16
+static void psxBios_PAD_dr() { // 16
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x16]);
 #endif
@@ -1586,7 +1586,7 @@ void psxBios_PAD_dr() { // 16
 	v0 = -1; pc0 = ra;
 }
 
-void psxBios_ReturnFromException() { // 17
+static void psxBios_ReturnFromException() { // 17
 	LoadRegs();
 
 	pc0 = psxRegs.CP0.n.EPC;
@@ -1596,7 +1596,7 @@ void psxBios_ReturnFromException() { // 17
 						  ((psxRegs.CP0.n.Status & 0x3c) >> 2);
 }
 
-void psxBios_ResetEntryInt() { // 18
+static void psxBios_ResetEntryInt() { // 18
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x18]);
 #endif
@@ -1605,7 +1605,7 @@ void psxBios_ResetEntryInt() { // 18
 	pc0 = ra;
 }
 
-void psxBios_HookEntryInt() { // 19
+static void psxBios_HookEntryInt() { // 19
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x19]);
 #endif
@@ -1614,7 +1614,7 @@ void psxBios_HookEntryInt() { // 19
 	pc0 = ra;
 }
 
-void psxBios_UnDeliverEvent() { // 0x20
+static void psxBios_UnDeliverEvent() { // 0x20
 	int ev, spec;
 	int i;
 
@@ -1675,7 +1675,7 @@ void psxBios_UnDeliverEvent() { // 0x20
  *	int open(char *name , int mode);
  */
 
-void psxBios_open() { // 0x32
+static void psxBios_open() { // 0x32
 	int i;
 	char *ptr;
 
@@ -1700,7 +1700,7 @@ void psxBios_open() { // 0x32
  *	int lseek(int fd , int offset , int whence);
  */
 
-void psxBios_lseek() { // 0x33
+static void psxBios_lseek() { // 0x33
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s: %x, %x, %x\n", biosB0n[0x33], a0, a1, a2);
 #endif
@@ -1737,7 +1737,7 @@ void psxBios_lseek() { // 0x33
  *	int read(int fd , void *buf , int nbytes);
  */
 
-void psxBios_read() { // 0x34
+static void psxBios_read() { // 0x34
 	char *ptr;
 
 #ifdef PSXBIOS_LOG
@@ -1771,7 +1771,7 @@ void psxBios_read() { // 0x34
  *	int write(int fd , void *buf , int nbytes);
  */
 
-void psxBios_write() { // 0x35/0x03
+static void psxBios_write() { // 0x35/0x03
 	char *ptr;
 
 	if (a0 == 1) { // stdout
@@ -1800,7 +1800,7 @@ void psxBios_write() { // 0x35/0x03
  *	int close(int fd);
  */
 
-void psxBios_close() { // 0x36
+static void psxBios_close() { // 0x36
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x36], a0);
 #endif
@@ -1809,12 +1809,12 @@ void psxBios_close() { // 0x36
 	pc0 = ra;
 }
 
-void psxBios_putchar() { // 3d
+static void psxBios_putchar() { // 3d
 	SysPrintf("%c", (char)a0);
 	pc0 = ra;
 }
 
-void psxBios_puts() { // 3e/3f
+static void psxBios_puts() { // 3e/3f
 	SysPrintf(Ra0);
 	pc0 = ra;
 }
@@ -1854,7 +1854,7 @@ int nfile;
  *	struct DIRENTRY* firstfile(char *name,struct DIRENTRY *dir);
  */
  
-void psxBios_firstfile() { // 42
+static void psxBios_firstfile() { // 42
 	struct DIRENTRY *dir = (struct DIRENTRY *)Ra1;
 	u32 _dir = a1;
 	char *ptr;
@@ -1885,7 +1885,7 @@ void psxBios_firstfile() { // 42
  *	struct DIRENTRY* nextfile(struct DIRENTRY *dir);
  */
 
-void psxBios_nextfile() { // 43
+static void psxBios_nextfile() { // 43
 	struct DIRENTRY *dir = (struct DIRENTRY *)Ra0;
 	u32 _dir = a0;
 	char *ptr;
@@ -1929,7 +1929,7 @@ void psxBios_nextfile() { // 43
  *	int rename(char *old, char *new);
  */
 
-void psxBios_rename() { // 44
+static void psxBios_rename() { // 44
 	char *ptr;
 	int i;
 
@@ -1968,7 +1968,7 @@ void psxBios_rename() { // 44
  *	int delete(char *name);
  */
 
-void psxBios_delete() { // 45
+static void psxBios_delete() { // 45
 	char *ptr;
 	int i;
 
@@ -1989,7 +1989,7 @@ void psxBios_delete() { // 45
 	pc0 = ra;
 }
 
-void psxBios_InitCARD() { // 4a
+static void psxBios_InitCARD() { // 4a
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x4a], a0);
 #endif
@@ -1999,7 +1999,7 @@ void psxBios_InitCARD() { // 4a
 	pc0 = ra;
 }
 
-void psxBios_StartCARD() { // 4b
+static void psxBios_StartCARD() { // 4b
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x4b]);
 #endif
@@ -2009,7 +2009,7 @@ void psxBios_StartCARD() { // 4b
 	pc0 = ra;
 }
 
-void psxBios_StopCARD() { // 4c
+static void psxBios_StopCARD() { // 4c
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x4c]);
 #endif
@@ -2019,7 +2019,7 @@ void psxBios_StopCARD() { // 4c
 	pc0 = ra;
 }
 
-void psxBios__card_write() { // 0x4e
+static void psxBios__card_write() { // 0x4e
 	int port;
 
 #ifdef PSXBIOS_LOG
@@ -2043,7 +2043,7 @@ void psxBios__card_write() { // 0x4e
 	v0 = 1; pc0 = ra;
 }
 
-void psxBios__card_read() { // 0x4f
+static void psxBios__card_read() { // 0x4f
 	int port;
 
 #ifdef PSXBIOS_LOG
@@ -2065,7 +2065,7 @@ void psxBios__card_read() { // 0x4f
 	v0 = 1; pc0 = ra;
 }
 
-void psxBios__new_card() { // 0x50
+static void psxBios__new_card() { // 0x50
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x50]);
 #endif
@@ -2073,7 +2073,7 @@ void psxBios__new_card() { // 0x50
 	pc0 = ra;
 }
 
-void psxBios_Krom2RawAdd() { // 0x51
+static void psxBios_Krom2RawAdd() { // 0x51
 	int i = 0;
 
 	const u32 table_8140[][2] = {
@@ -2116,7 +2116,7 @@ void psxBios_Krom2RawAdd() { // 0x51
 	pc0 = ra;
 }
 
-void psxBios_GetC0Table() { // 56
+static void psxBios_GetC0Table() { // 56
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x56]);
 #endif
@@ -2124,7 +2124,7 @@ void psxBios_GetC0Table() { // 56
 	v0 = 0x674; pc0 = ra;
 }
 
-void psxBios_GetB0Table() { // 57
+static void psxBios_GetB0Table() { // 57
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x57]);
 #endif
@@ -2132,7 +2132,7 @@ void psxBios_GetB0Table() { // 57
 	v0 = 0x874; pc0 = ra;
 }
 
-void psxBios__card_chan() { // 0x58
+static void psxBios__card_chan() { // 0x58
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x58]);
 #endif
@@ -2141,7 +2141,7 @@ void psxBios__card_chan() { // 0x58
 	pc0 = ra;
 }
 
-void psxBios_ChangeClearPad() { // 5b
+static void psxBios_ChangeClearPad() { // 5b
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x5b], a0);
 #endif	
@@ -2155,7 +2155,7 @@ void psxBios_ChangeClearPad() { // 5b
  * int SysEnqIntRP(int index , long *queue);
  */
 
-void psxBios_SysEnqIntRP() { // 02
+static void psxBios_SysEnqIntRP() { // 02
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s: %x\n", biosC0n[0x02] ,a0);
 #endif
@@ -2169,7 +2169,7 @@ void psxBios_SysEnqIntRP() { // 02
  * int SysDeqIntRP(int index , long *queue);
  */
 
-void psxBios_SysDeqIntRP() { // 03
+static void psxBios_SysDeqIntRP() { // 03
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("psxBios_%s: %x\n", biosC0n[0x03], a0);
 #endif
@@ -2179,7 +2179,7 @@ void psxBios_SysDeqIntRP() { // 03
 	v0 = 0; pc0 = ra;
 }
 
-void psxBios_ChangeClearRCnt() { // 0a
+static void psxBios_ChangeClearRCnt() { // 0a
 	u32 *ptr;
 
 #ifdef PSXBIOS_LOG
@@ -2194,7 +2194,7 @@ void psxBios_ChangeClearRCnt() { // 0a
 	pc0 = ra;
 }
 
-void psxBios_dummy() { 
+static void psxBios_dummy() { 
 #ifdef PSXBIOS_LOG
 	PSXBIOS_LOG("unk %x call: %x\n", pc0 & 0x1fffff, t1);
 #endif
@@ -2628,7 +2628,7 @@ void psxBiosShutdown() {
 	} \
 }
 
-void biosInterrupt() {
+static void biosInterrupt() {
 	int i, bufcount;
 
 //	if (psxHu32(0x1070) & 0x1) { // Vsync
diff --git a/libpcsxcore/psxbios.h b/libpcsxcore/psxbios.h
index 635b35a5..ab7b0370 100644
--- a/libpcsxcore/psxbios.h
+++ b/libpcsxcore/psxbios.h
@@ -34,9 +34,9 @@ extern char *biosA0n[256];
 extern char *biosB0n[256];
 extern char *biosC0n[256];
 
-void psxBiosInit();
-void psxBiosShutdown();
-void psxBiosException();
+void psxBiosInit(void);
+void psxBiosShutdown(void);
+void psxBiosException(void);
 void psxBiosFreeze(int Mode);
 
 extern void (*biosA0[256])();
diff --git a/libpcsxcore/psxcommon.h b/libpcsxcore/psxcommon.h
index 73d130ba..baede5a7 100644
--- a/libpcsxcore/psxcommon.h
+++ b/libpcsxcore/psxcommon.h
@@ -77,6 +77,7 @@ typedef uint8_t boolean;
 #define __inline inline
 
 // Enables NLS/internationalization if active
+#include <locale.h>
 #ifdef ENABLE_NLS
 
 #include <libintl.h>
diff --git a/libpcsxcore/psxcounters.c b/libpcsxcore/psxcounters.c
index 70d16f85..a1a36748 100644
--- a/libpcsxcore/psxcounters.c
+++ b/libpcsxcore/psxcounters.c
@@ -65,7 +65,7 @@ static const u32 CountToOverflow  = 0;
 static const u32 CountToTarget    = 1;
 
 static const u32 FrameRate[]      = { 60, 50 };
-//static const u32 VBlankStart[]    = { 240, 256 };

+//static const u32 VBlankStart[]    = { 240, 256 };
 static const u32 VBlankStart[]    = { 243, 256 };
 static const u32 HSyncTotal[]     = { 263, 313 };
 static const u32 SpuUpdInterval[] = { 23, 22 };
@@ -95,13 +95,11 @@ void verboseLog( s32 level, const char *str, ... )
     if( level <= VerboseLevel )
     {
         va_list va;
-        char buf[ 4096 ];
 
         va_start( va, str );
-        vsprintf( buf, str, va );
+        vprintf( str, va );
         va_end( va );
 
-        printf( buf );
         fflush( stdout );
     }
 }
diff --git a/libpcsxcore/psxinterpreter.c b/libpcsxcore/psxinterpreter.c
index 69d0061f..eedb7452 100644
--- a/libpcsxcore/psxinterpreter.c
+++ b/libpcsxcore/psxinterpreter.c
@@ -47,7 +47,7 @@ void (*psxREG[32])();
 void (*psxCP0[32])();
 void (*psxCP2[64])();
 void (*psxCP2BSC[32])();
-

+
 static void delayRead(int reg, u32 bpc) {
 	u32 rold, rnew;
 
@@ -155,10 +155,10 @@ int psxTestLoadDelay(int reg, u32 tmp) {
 			switch (_tRt_) {
 				case 0x00: case 0x01:
 				case 0x10: case 0x11: // BLTZ/BGEZ...
-					// Xenogears - lbu v0 / beq v0

-					// - no load delay (fixes battle loading)

-					break;

-

+					// Xenogears - lbu v0 / beq v0
+					// - no load delay (fixes battle loading)
+					break;
+
 					if (_tRs_ == reg) return 2;
 					break;
 			}
@@ -170,18 +170,18 @@ int psxTestLoadDelay(int reg, u32 tmp) {
 			break;
 
 		case 0x04: case 0x05: // BEQ/BNE
-			// Xenogears - lbu v0 / beq v0

-			// - no load delay (fixes battle loading)

-			break;

-

+			// Xenogears - lbu v0 / beq v0
+			// - no load delay (fixes battle loading)
+			break;
+
 			if (_tRs_ == reg || _tRt_ == reg) return 2;
 			break;
 
 		case 0x06: case 0x07: // BLEZ/BGTZ
-			// Xenogears - lbu v0 / beq v0

-			// - no load delay (fixes battle loading)

-			break;

-

+			// Xenogears - lbu v0 / beq v0
+			// - no load delay (fixes battle loading)
+			break;
+
 			if (_tRs_ == reg) return 2;
 			break;
 
@@ -265,9 +265,9 @@ void psxDelayTest(int reg, u32 bpc) {
 	u32 *code;
 	u32 tmp;
 
-	// Don't execute yet - just peek

-	code = Read_ICache(bpc, TRUE);

-

+	// Don't execute yet - just peek
+	code = Read_ICache(bpc, TRUE);
+
 	tmp = ((code == NULL) ? 0 : SWAP32(*code));
 	branch = 1;
 
@@ -409,7 +409,7 @@ static int psxDelayBranchTest(u32 tar1) {
 	return psxDelayBranchExec(tmp2);
 }
 
-__inline void doBranch(u32 tar) {
+static __inline void doBranch(u32 tar) {
 	u32 *code;
 	u32 tmp;
 
@@ -420,9 +420,9 @@ __inline void doBranch(u32 tar) {
 	if (psxDelayBranchTest(tar))
 		return;
 
-	// branch delay slot

-	code = Read_ICache(psxRegs.pc, TRUE);

-

+	// branch delay slot
+	code = Read_ICache(psxRegs.pc, TRUE);
+
 	psxRegs.code = ((code == NULL) ? 0 : SWAP32(*code));
 
 	debugI();
@@ -508,10 +508,10 @@ void psxDIV() {
 		_i32(_rLo_) = _i32(_rRs_) / _i32(_rRt_);
 		_i32(_rHi_) = _i32(_rRs_) % _i32(_rRt_);
 	}
-	else {

-		_i32(_rLo_) = 0xffffffff;

-		_i32(_rHi_) = _i32(_rRs_);

-	}

+	else {
+		_i32(_rLo_) = 0xffffffff;
+		_i32(_rHi_) = _i32(_rRs_);
+	}
 }
 
 void psxDIVU() {
@@ -519,10 +519,10 @@ void psxDIVU() {
 		_rLo_ = _rRs_ / _rRt_;
 		_rHi_ = _rRs_ % _rRt_;
 	}
-	else {

-		_rLo_ = 0xffffffff;

-		_rHi_ = _rRs_;

-	}

+	else {
+		_rLo_ = 0xffffffff;
+		_rHi_ = _rRs_;
+	}
 }
 
 void psxMULT() {
@@ -647,18 +647,18 @@ void psxJALR() {
 #define _oB_ (_u32(_rRs_) + _Imm_)
 
 void psxLB() {
-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-

-

+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+
+
 	if (_Rt_) {
 		_i32(_rRt_) = (signed char)psxMemRead8(_oB_); 
 	} else {
@@ -667,18 +667,18 @@ void psxLB() {
 }
 
 void psxLBU() {
-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-

-

+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+
+
 	if (_Rt_) {
 		_u32(_rRt_) = psxMemRead8(_oB_);
 	} else {
@@ -687,18 +687,18 @@ void psxLBU() {
 }
 
 void psxLH() {
-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-

-

+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+
+
 	if (_Rt_) {
 		_i32(_rRt_) = (short)psxMemRead16(_oB_);
 	} else {
@@ -707,18 +707,18 @@ void psxLH() {
 }
 
 void psxLHU() {
-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-

-

+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+
+
 	if (_Rt_) {
 		_u32(_rRt_) = psxMemRead16(_oB_);
 	} else {
@@ -727,18 +727,18 @@ void psxLHU() {
 }
 
 void psxLW() {
-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-

-

+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+
+
 	if (_Rt_) {
 		_u32(_rRt_) = psxMemRead32(_oB_);
 	} else {
@@ -753,19 +753,19 @@ void psxLWL() {
 	u32 addr = _oB_;
 	u32 shift = addr & 3;
 	u32 mem = psxMemRead32(addr & ~3);
-

-
-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-

+
+
+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+
 	if (!_Rt_) return;
 	_u32(_rRt_) =	( _u32(_rRt_) & LWL_MASK[shift]) | 
 					( mem << LWL_SHIFT[shift]);
@@ -788,20 +788,20 @@ void psxLWR() {
 	u32 shift = addr & 3;
 	u32 mem = psxMemRead32(addr & ~3);
 
-

-	

-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-

-

+
+	
+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+
+
 	if (!_Rt_) return;
 	_u32(_rRt_) =	( _u32(_rRt_) & LWR_MASK[shift]) | 
 					( mem >> LWR_SHIFT[shift]);
@@ -865,40 +865,40 @@ void psxSWR() {
 * Moves between GPR and COPx                             *
 * Format:  OP rt, fs                                     *
 *********************************************************/
-void psxMFC0()

-{

-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-

-	if (!_Rt_) return;

-	

-	_i32(_rRt_) = (int)_rFs_;

-}

-
-void psxCFC0()

-{

-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-

-	if (!_Rt_) return;

-	

-	_i32(_rRt_) = (int)_rFs_;

+void psxMFC0()
+{
+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+
+	if (!_Rt_) return;
+	
+	_i32(_rRt_) = (int)_rFs_;
+}
+
+void psxCFC0()
+{
+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+
+	if (!_Rt_) return;
+	
+	_i32(_rRt_) = (int)_rFs_;
 }
 
 void psxTestSWInts() {
@@ -932,40 +932,40 @@ __inline void MTC0(int reg, u32 val) {
 void psxMTC0() { MTC0(_Rd_, _u32(_rRt_)); }
 void psxCTC0() { MTC0(_Rd_, _u32(_rRt_)); }
 
-

-

-void psxMFC2()

-{

-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-	gteMFC2();

-}

-

-

-void psxCFC2()

-{

-	// load delay = 1 latency

-	if( branch == 0 )

-	{

-		// simulate: beq r0,r0,lw+4 / lw / (delay slot)

-		psxRegs.pc -= 4;

-		doBranch( psxRegs.pc + 4 );

-

-		return;

-	}

-

-	gteCFC2();

-}

-

-

+
+
+void psxMFC2()
+{
+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+	gteMFC2();
+}
+
+
+void psxCFC2()
+{
+	// load delay = 1 latency
+	if( branch == 0 )
+	{
+		// simulate: beq r0,r0,lw+4 / lw / (delay slot)
+		psxRegs.pc -= 4;
+		doBranch( psxRegs.pc + 4 );
+
+		return;
+	}
+
+	gteCFC2();
+}
+
+
 /*********************************************************
 * Unknow instruction (would generate an exception)       *
 * Format:  ?                                             *
@@ -989,13 +989,13 @@ void psxCOP0() {
 }
 
 void psxCOP2() {
-	if ((psxRegs.CP0.n.Status & 0x40000000) == 0 )

-		return;

-

+	if ((psxRegs.CP0.n.Status & 0x40000000) == 0 )
+		return;
+
 	psxCP2[_Funct_]();
 }
 
-void psxBASIC() {

+void psxBASIC() {
 	psxCP2BSC[_Rs_]();
 }
 
@@ -1067,7 +1067,7 @@ static int intInit() {
 }
 
 static void intReset() {
-	psxRegs.ICache_valid = FALSE;

+	psxRegs.ICache_valid = FALSE;
 }
 
 static void intExecute() {
@@ -1087,8 +1087,8 @@ static void intShutdown() {
 }
 
 // interpreter execution
-inline void execI() { 

-	u32 *code = Read_ICache(psxRegs.pc, FALSE);

+inline void execI() { 
+	u32 *code = Read_ICache(psxRegs.pc, FALSE);
 	psxRegs.code = ((code == NULL) ? 0 : SWAP32(*code));
 
 	debugI();
diff --git a/libpcsxcore/psxmem.c b/libpcsxcore/psxmem.c
index ba3f8a19..28e25e1e 100644
--- a/libpcsxcore/psxmem.c
+++ b/libpcsxcore/psxmem.c
@@ -31,9 +31,9 @@
 #endif
 
 s8 *psxM = NULL; // Kernel & User Memory (2 Meg)
-s8 *psxP = NULL; // Parallel Port (64K)
 s8 *psxR = NULL; // BIOS ROM (512K)
-s8 *psxH = NULL; // Scratch Pad (1K) & Hardware Registers (8K)
+// Parallel Port (64K) is attached to psxM
+// Scratch Pad (1K) & Hardware Registers (8K) are attached to psxM
 
 u8 **psxMemWLUT = NULL;
 u8 **psxMemRLUT = NULL;
@@ -65,13 +65,10 @@ int psxMemInit() {
 	memset(psxMemRLUT, 0, 0x10000 * sizeof(void *));
 	memset(psxMemWLUT, 0, 0x10000 * sizeof(void *));
 
-	psxM = mmap(0, 0x00220000,
+	psxM = mmap(0, PSXM_SIZE + PSXP_SIZE + PSXH_SIZE,
 		PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 
-	psxP = &psxM[0x200000];
-	psxH = &psxM[0x210000];
-
-	psxR = (s8 *)malloc(0x00080000);
+	psxR = (s8 *)malloc(PSXR_SIZE);
 
 	if (psxMemRLUT == NULL || psxMemWLUT == NULL || 
 		psxM == NULL || psxP == NULL || psxH == NULL) {
@@ -109,8 +106,8 @@ void psxMemReset() {
 	FILE *f = NULL;
 	char bios[1024];
 
-	memset(psxM, 0, 0x00200000);
-	memset(psxP, 0, 0x00010000);
+	memset(psxM, 0, PSXM_SIZE);
+	memset(psxP, 0, PSXP_SIZE);
 
 	// Load BIOS
 	if (strcmp(Config.Bios, "HLE") != 0) {
@@ -119,10 +116,11 @@ void psxMemReset() {
 
 		if (f == NULL) {
 			SysMessage(_("Could not open BIOS:\"%s\". Enabling HLE Bios!\n"), bios);
-			memset(psxR, 0, 0x80000);
+			memset(psxR, 0, PSXR_SIZE);
 			Config.HLE = TRUE;
 		} else {
-			fread(psxR, 1, 0x80000, f);
+			if(fread(psxR, PSXR_SIZE, 1, f) != 1)
+				perror(bios);
 			fclose(f);
 			Config.HLE = FALSE;
 		}
@@ -130,7 +128,7 @@ void psxMemReset() {
 }
 
 void psxMemShutdown() {
-	munmap(psxM, 0x00220000);
+	munmap(psxM, PSXM_SIZE + PSXP_SIZE + PSXH_SIZE);
 
 	free(psxR);
 	free(psxMemRLUT);
@@ -325,15 +323,15 @@ void psxMemWrite32(u32 mem, u32 value) {
 			} else {
 				int i;
 
-				// a0-44: used for cache flushing

+				// a0-44: used for cache flushing
 				switch (value) {
 					case 0x800: case 0x804:
 						if (writeok == 0) break;
 						writeok = 0;
 						memset(psxMemWLUT + 0x0000, 0, 0x80 * sizeof(void *));
 						memset(psxMemWLUT + 0x8000, 0, 0x80 * sizeof(void *));
-						memset(psxMemWLUT + 0xa000, 0, 0x80 * sizeof(void *));

-

+						memset(psxMemWLUT + 0xa000, 0, 0x80 * sizeof(void *));
+
 						psxRegs.ICache_valid = 0;
 						break;
 					case 0x00: case 0x1e988:
diff --git a/libpcsxcore/psxmem.h b/libpcsxcore/psxmem.h
index d9fee002..a41604b7 100644
--- a/libpcsxcore/psxmem.h
+++ b/libpcsxcore/psxmem.h
@@ -50,75 +50,83 @@ extern "C" {
 #endif
 
 extern s8 *psxM;
-#define psxMs8(mem)		psxM[(mem) & 0x1fffff]
-#define psxMs16(mem)	(SWAP16(*(s16 *)&psxM[(mem) & 0x1fffff]))
-#define psxMs32(mem)	(SWAP32(*(s32 *)&psxM[(mem) & 0x1fffff]))
-#define psxMu8(mem)		(*(u8 *)&psxM[(mem) & 0x1fffff])
-#define psxMu16(mem)	(SWAP16(*(u16 *)&psxM[(mem) & 0x1fffff]))
-#define psxMu32(mem)	(SWAP32(*(u32 *)&psxM[(mem) & 0x1fffff]))
-
-#define psxMs8ref(mem)	psxM[(mem) & 0x1fffff]
-#define psxMs16ref(mem)	(*(s16 *)&psxM[(mem) & 0x1fffff])
-#define psxMs32ref(mem)	(*(s32 *)&psxM[(mem) & 0x1fffff])
-#define psxMu8ref(mem)	(*(u8 *)&psxM[(mem) & 0x1fffff])
-#define psxMu16ref(mem)	(*(u16 *)&psxM[(mem) & 0x1fffff])
-#define psxMu32ref(mem)	(*(u32 *)&psxM[(mem) & 0x1fffff])
-
-extern s8 *psxP;
-#define psxPs8(mem)	    psxP[(mem) & 0xffff]
-#define psxPs16(mem)	(SWAP16(*(s16 *)&psxP[(mem) & 0xffff]))
-#define psxPs32(mem)	(SWAP32(*(s32 *)&psxP[(mem) & 0xffff]))
-#define psxPu8(mem)		(*(u8 *)&psxP[(mem) & 0xffff])
-#define psxPu16(mem)	(SWAP16(*(u16 *)&psxP[(mem) & 0xffff]))
-#define psxPu32(mem)	(SWAP32(*(u32 *)&psxP[(mem) & 0xffff]))
-
-#define psxPs8ref(mem)	psxP[(mem) & 0xffff]
-#define psxPs16ref(mem)	(*(s16 *)&psxP[(mem) & 0xffff])
-#define psxPs32ref(mem)	(*(s32 *)&psxP[(mem) & 0xffff])
-#define psxPu8ref(mem)	(*(u8 *)&psxP[(mem) & 0xffff])
-#define psxPu16ref(mem)	(*(u16 *)&psxP[(mem) & 0xffff])
-#define psxPu32ref(mem)	(*(u32 *)&psxP[(mem) & 0xffff])
-
+#define PSXM_SIZE 0x200000
+#define psxMs8(mem)		psxM[(mem) & (PSXM_SIZE - 1)]
+#define psxMs16(mem)	(SWAP16(*(s16 *)&psxM[(mem) & (PSXM_SIZE - 1)]))
+#define psxMs32(mem)	(SWAP32(*(s32 *)&psxM[(mem) & (PSXM_SIZE - 1)]))
+#define psxMu8(mem)		(*(u8 *)&psxM[(mem) & (PSXM_SIZE - 1)])
+#define psxMu16(mem)	(SWAP16(*(u16 *)&psxM[(mem) & (PSXM_SIZE - 1)]))
+#define psxMu32(mem)	(SWAP32(*(u32 *)&psxM[(mem) & (PSXM_SIZE - 1)]))
+
+#define psxMs8ref(mem)	psxM[(mem) & (PSXM_SIZE - 1)]
+#define psxMs16ref(mem)	(*(s16 *)&psxM[(mem) & (PSXM_SIZE - 1)])
+#define psxMs32ref(mem)	(*(s32 *)&psxM[(mem) & (PSXM_SIZE - 1)])
+#define psxMu8ref(mem)	(*(u8 *)&psxM[(mem) & (PSXM_SIZE - 1)])
+#define psxMu16ref(mem)	(*(u16 *)&psxM[(mem) & (PSXM_SIZE - 1)])
+#define psxMu32ref(mem)	(*(u32 *)&psxM[(mem) & (PSXM_SIZE - 1)])
+
+#define PSXP_OFFSET PSXM_SIZE
+#define PSXP_SIZE 0x10000
+#define psxP (&psxM[PSXP_OFFSET])
+#define psxPs8(mem)	    psxP[(mem) & (PSXP_SIZE - 1)]
+#define psxPs16(mem)	(SWAP16(*(s16 *)&psxP[(mem) & (PSXP_SIZE - 1)]))
+#define psxPs32(mem)	(SWAP32(*(s32 *)&psxP[(mem) & (PSXP_SIZE - 1)]))
+#define psxPu8(mem)		(*(u8 *)&psxP[(mem) & (PSXP_SIZE - 1)])
+#define psxPu16(mem)	(SWAP16(*(u16 *)&psxP[(mem) & (PSXP_SIZE - 1)]))
+#define psxPu32(mem)	(SWAP32(*(u32 *)&psxP[(mem) & (PSXP_SIZE - 1)]))
+
+#define psxPs8ref(mem)	psxP[(mem) & (PSXP_SIZE - 1)]
+#define psxPs16ref(mem)	(*(s16 *)&psxP[(mem) & (PSXP_SIZE - 1)])
+#define psxPs32ref(mem)	(*(s32 *)&psxP[(mem) & (PSXP_SIZE - 1)])
+#define psxPu8ref(mem)	(*(u8 *)&psxP[(mem) & (PSXP_SIZE - 1)])
+#define psxPu16ref(mem)	(*(u16 *)&psxP[(mem) & (PSXP_SIZE - 1)])
+#define psxPu32ref(mem)	(*(u32 *)&psxP[(mem) & (PSXP_SIZE - 1)])
+
+#define PSXR_SIZE 0x80000
 extern s8 *psxR;
-#define psxRs8(mem)		psxR[(mem) & 0x7ffff]
-#define psxRs16(mem)	(SWAP16(*(s16 *)&psxR[(mem) & 0x7ffff]))
-#define psxRs32(mem)	(SWAP32(*(s32 *)&psxR[(mem) & 0x7ffff]))
-#define psxRu8(mem)		(*(u8* )&psxR[(mem) & 0x7ffff])
-#define psxRu16(mem)	(SWAP16(*(u16 *)&psxR[(mem) & 0x7ffff]))
-#define psxRu32(mem)	(SWAP32(*(u32 *)&psxR[(mem) & 0x7ffff]))
-
-#define psxRs8ref(mem)	psxR[(mem) & 0x7ffff]
-#define psxRs16ref(mem)	(*(s16*)&psxR[(mem) & 0x7ffff])
-#define psxRs32ref(mem)	(*(s32*)&psxR[(mem) & 0x7ffff])
-#define psxRu8ref(mem)	(*(u8 *)&psxR[(mem) & 0x7ffff])
-#define psxRu16ref(mem)	(*(u16*)&psxR[(mem) & 0x7ffff])
-#define psxRu32ref(mem)	(*(u32*)&psxR[(mem) & 0x7ffff])
-
-extern s8 *psxH;
-#define psxHs8(mem)		psxH[(mem) & 0xffff]
-#define psxHs16(mem)	(SWAP16(*(s16 *)&psxH[(mem) & 0xffff]))
-#define psxHs32(mem)	(SWAP32(*(s32 *)&psxH[(mem) & 0xffff]))
-#define psxHu8(mem)		(*(u8 *)&psxH[(mem) & 0xffff])
-#define psxHu16(mem)	(SWAP16(*(u16 *)&psxH[(mem) & 0xffff]))
-#define psxHu32(mem)	(SWAP32(*(u32 *)&psxH[(mem) & 0xffff]))
-
-#define psxHs8ref(mem)	psxH[(mem) & 0xffff]
-#define psxHs16ref(mem)	(*(s16 *)&psxH[(mem) & 0xffff])
-#define psxHs32ref(mem)	(*(s32 *)&psxH[(mem) & 0xffff])
-#define psxHu8ref(mem)	(*(u8 *)&psxH[(mem) & 0xffff])
-#define psxHu16ref(mem)	(*(u16 *)&psxH[(mem) & 0xffff])
-#define psxHu32ref(mem)	(*(u32 *)&psxH[(mem) & 0xffff])
+#define psxRs8(mem)		psxR[(mem) & (PSXR_SIZE - 1)]
+#define psxRs16(mem)	(SWAP16(*(s16 *)&psxR[(mem) & (PSXR_SIZE - 1)]))
+#define psxRs32(mem)	(SWAP32(*(s32 *)&psxR[(mem) & (PSXR_SIZE - 1)]))
+#define psxRu8(mem)		(*(u8* )&psxR[(mem) & (PSXR_SIZE - 1)])
+#define psxRu16(mem)	(SWAP16(*(u16 *)&psxR[(mem) & (PSXR_SIZE - 1)]))
+#define psxRu32(mem)	(SWAP32(*(u32 *)&psxR[(mem) & (PSXR_SIZE - 1)]))
+
+#define psxRs8ref(mem)	psxR[(mem) & (PSXR_SIZE - 1)]
+#define psxRs16ref(mem)	(*(s16*)&psxR[(mem) & (PSXR_SIZE - 1)])
+#define psxRs32ref(mem)	(*(s32*)&psxR[(mem) & (PSXR_SIZE - 1)])
+#define psxRu8ref(mem)	(*(u8 *)&psxR[(mem) & (PSXR_SIZE - 1)])
+#define psxRu16ref(mem)	(*(u16*)&psxR[(mem) & (PSXR_SIZE - 1)])
+#define psxRu32ref(mem)	(*(u32*)&psxR[(mem) & (PSXR_SIZE - 1)])
+
+#define PSXH_SIZE 0x10000
+#define PSXH_OFFSET (PSXP_OFFSET + PSXP_SIZE)
+#define psxH (&psxM[PSXH_OFFSET])
+#define psxHs8(mem)		psxH[(mem) & (PSXH_SIZE - 1)]
+#define psxHs16(mem)	(SWAP16(*(s16 *)&psxH[(mem) & (PSXH_SIZE - 1)]))
+#define psxHs32(mem)	(SWAP32(*(s32 *)&psxH[(mem) & (PSXH_SIZE - 1)]))
+#define psxHu8(mem)		(*(u8 *)&psxH[(mem) & (PSXH_SIZE - 1)])
+#define psxHu16(mem)	(SWAP16(*(u16 *)&psxH[(mem) & (PSXH_SIZE - 1)]))
+#define psxHu32(mem)	(SWAP32(*(u32 *)&psxH[(mem) & (PSXH_SIZE - 1)]))
+
+#define psxHs8ref(mem)	psxH[(mem) & (PSXH_SIZE - 1)]
+#define psxHs16ref(mem)	(*(s16 *)&psxH[(mem) & (PSXH_SIZE - 1)])
+#define psxHs32ref(mem)	(*(s32 *)&psxH[(mem) & (PSXH_SIZE - 1)])
+#define psxHu8ref(mem)	(*(u8 *)&psxH[(mem) & (PSXH_SIZE - 1)])
+#define psxHu16ref(mem)	(*(u16 *)&psxH[(mem) & (PSXH_SIZE - 1)])
+#define psxHu32ref(mem)	(*(u32 *)&psxH[(mem) & (PSXH_SIZE - 1)])
 
 extern u8 **psxMemWLUT;
 extern u8 **psxMemRLUT;
 
 #define PSXM(mem)		(psxMemRLUT[(mem) >> 16] == 0 ? NULL : (u8*)(psxMemRLUT[(mem) >> 16] + ((mem) & 0xffff)))
-#define PSXMs8(mem)		(*(s8 *)PSXM(mem))
-#define PSXMs16(mem)	(SWAP16(*(s16 *)PSXM(mem)))
-#define PSXMs32(mem)	(SWAP32(*(s32 *)PSXM(mem)))
-#define PSXMu8(mem)		(*(u8 *)PSXM(mem))
-#define PSXMu16(mem)	(SWAP16(*(u16 *)PSXM(mem)))
-#define PSXMu32(mem)	(SWAP32(*(u32 *)PSXM(mem)))
+/* prevent crashes */
+#define PSXMt(t, mem)		(psxMemRLUT[(mem) >> 16] == 0 ? (t)0 : *(t*)(psxMemRLUT[(mem) >> 16] + ((mem) & 0xffff)))
+#define PSXMs8(mem)		PSXMt(s8, mem)
+#define PSXMs16(mem)	(SWAP16(PSXMt(s16, mem)))
+#define PSXMs32(mem)	(SWAP32(PSXMt(s32, mem)))
+#define PSXMu8(mem)		PSXMt(u8, mem)
+#define PSXMu16(mem)	(SWAP16(PSXMt(u16, mem)))
+#define PSXMu32(mem)	(SWAP32(PSXMt(u32, mem)))
 
 #define PSXMu32ref(mem)	(*(u32 *)PSXM(mem))
 
diff --git a/libpcsxcore/r3000a.h b/libpcsxcore/r3000a.h
index f2bdecd7..2c4e57f5 100644
--- a/libpcsxcore/r3000a.h
+++ b/libpcsxcore/r3000a.h
@@ -333,6 +333,123 @@ void psxDelayTest(int reg, u32 bpc);
 void psxTestSWInts();
 void psxJumpTest();
 
+/* psxinterpreter for rec fallbacks */
+void psxNULL(void);
+void psxSPECIAL(void);
+void psxREGIMM(void);
+void psxJ(void);
+void psxJAL(void);
+void psxBEQ(void);
+void psxBNE(void);
+void psxBLEZ(void);
+void psxBGTZ(void);
+void psxADDI(void);
+void psxADDIU(void);
+void psxSLTI(void);
+void psxSLTIU(void);
+void psxANDI(void);
+void psxORI(void);
+void psxXORI(void);
+void psxLUI(void);
+void psxCOP0(void);
+void psxCOP2(void);
+void psxLB(void);
+void psxLH(void);
+void psxLWL(void);
+void psxLW(void);
+void psxLBU(void);
+void psxLHU(void);
+void psxLWR(void);
+void psxSB(void);
+void psxSH(void);
+void psxSWL(void);
+void psxSW(void);
+void psxSWR(void);
+void psxNULL(void);
+void gteLWC2(void);
+void psxNULL(void);
+void gteSWC2(void);
+void psxHLE(void);
+void psxSLL(void);
+void psxSRL(void);
+void psxSRA(void);
+void psxSLLV(void);
+void psxSRLV(void);
+void psxSRAV(void);
+void psxJR(void);
+void psxJALR(void);
+void psxSYSCALL(void);
+void psxBREAK(void);
+void psxMFHI(void);
+void psxMTHI(void);
+void psxMFLO(void);
+void psxMTLO(void);
+void psxMULT(void);
+void psxMULTU(void);
+void psxDIV(void);
+void psxDIVU(void);
+void psxADD(void);
+void psxADDU(void);
+void psxSUB(void);
+void psxSUBU(void);
+void psxAND(void);
+void psxOR(void);
+void psxXOR(void);
+void psxNOR(void);
+void psxNULL(void);
+void psxSLT(void);
+void psxSLTU(void);
+void psxBLTZ(void);
+void psxBGEZ(void);
+void psxBLTZAL(void);
+void psxBGEZAL(void);
+void psxMFC0(void);
+void psxCFC0(void);
+void psxMTC0(void);
+void psxCTC0(void);
+void psxRFE(void);
+void psxBASIC(void);
+void gteRTPS(void);
+void gteNCLIP(void);
+void psxNULL(void);
+void gteOP(void);
+void gteDPCS(void);
+void gteINTPL(void);
+void gteMVMVA(void);
+void gteNCDS(void);
+void gteCDP(void);
+void gteNCDT(void);
+void psxNULL(void);
+void gteNCCS(void);
+void gteCC(void);
+void gteNCS(void);
+void gteNCT(void);
+void gteSQR(void);
+void gteDCPL(void);
+void gteDPCT(void);
+void gteAVSZ3(void);
+void gteAVSZ4(void);
+void gteRTPT(void);
+void psxNULL(void);
+void gteGPF(void);
+void gteGPL(void);
+void gteNCCT(void);
+void psxMFC2(void);
+void psxCFC2(void);
+void gteMTC2(void);
+void gteCTC2(void);
+extern void (*psxBSC[])();
+
+/* for table-based unaligned access implementations */
+extern u32 LWL_MASK[4];
+extern u32 LWL_SHIFT[4];
+extern u32 LWR_MASK[4];
+extern u32 LWR_SHIFT[4];
+extern u32 SWL_MASK[4];
+extern u32 SWL_SHIFT[4];
+extern u32 SWR_MASK[4];
+extern u32 SWR_SHIFT[4];
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/libpcsxcore/sio.c b/libpcsxcore/sio.c
index e1b8a3e1..1659b73a 100644
--- a/libpcsxcore/sio.c
+++ b/libpcsxcore/sio.c
@@ -38,12 +38,16 @@
 
 // Control Flags
 #define TX_PERM		0x0001
-#define DTR			0x0002
+#define DTR_PERM	0x0002
 #define RX_PERM		0x0004
 #define BREAK		0x0008
 #define RESET_ERR	0x0010
 #define RTS			0x0020
 #define SIO_RESET	0x0040
+#define TX_INTEN	0x0400
+#define RX_INTEN	0x0800
+#define DSR_INTEN	0x1000
+#define DTR		0x2000
 
 // *** FOR WORKS ON PADS AND MEMORY CARDS *****
 
@@ -121,21 +125,12 @@ static int DongleInit;
 // ePSXe 1.7.0
 //#define SIO_CYCLES 635
 
-unsigned char reverse_8( unsigned char bits )
+static unsigned char reverse_8( unsigned char bits )
 {
-	unsigned char tmp;
-	int lcv;
-
-	tmp = 0;
-	for( lcv = 0; lcv < 8; lcv++ )
-	{
-		tmp >>= 1;
-		tmp |= (bits & 0x80);
-
-		bits <<= 1;
-	}
-
-	return tmp;
+	bits = ((bits & 0xaa) >> 1) | ((bits & 0x55) << 1);
+	bits = ((bits & 0xcc) >> 2) | ((bits & 0x33) << 2);
+	bits = ((bits & 0xf0) >> 4) | ((bits & 0x0f) << 4);
+	return bits;
 }
 
 
@@ -145,75 +140,75 @@ void sioWrite8(unsigned char value) {
 #endif
 	switch (padst) {
 		case 1: SIO_INT(SIO_CYCLES);
-			/*

-			$41-4F

-			$41 = Find bits in poll respones

-			$42 = Polling command

-			$43 = Config mode (Dual shock?)

-			$44 = Digital / Analog (after $F3)

-			$45 = Get status info (Dual shock?)

-

-			ID:

-			$41 = Digital

-			$73 = Analogue Red LED

-			$53 = Analogue Green LED

-

-			$23 = NegCon

-			$12 = Mouse

-			*/

-

+			/*
+			$41-4F
+			$41 = Find bits in poll respones
+			$42 = Polling command
+			$43 = Config mode (Dual shock?)
+			$44 = Digital / Analog (after $F3)
+			$45 = Get status info (Dual shock?)
+
+			ID:
+			$41 = Digital
+			$73 = Analogue Red LED
+			$53 = Analogue Green LED
+
+			$23 = NegCon
+			$12 = Mouse
+			*/
+
 			if ((value & 0x40) == 0x40) {
 				padst = 2; parp = 1;
 				if (!Config.UseNet) {
-					switch (CtrlReg & 0x2002) {
-						case 0x0002:
+					switch (CtrlReg & (DTR_PERM|DTR)) {
+						case DTR_PERM:
 							buf[parp] = PAD1_poll(value);
 							break;
-						case 0x2002:
+						case (DTR_PERM|DTR):
 							buf[parp] = PAD2_poll(value);
 							break;
 					}
 				}/* else {
-//					SysPrintf("%x: %x, %x, %x, %x\n", CtrlReg&0x2002, buf[2], buf[3], buf[4], buf[5]);
+//					SysPrintf("%x: %x, %x, %x, %x\n", CtrlReg&(DTR_PERM|DTR), buf[2], buf[3], buf[4], buf[5]);
 				}*/
 
 				if (!(buf[parp] & 0x0f)) {
 					bufcount = 2 + 32;
 				} else {
 					bufcount = 2 + (buf[parp] & 0x0f) * 2;
-				}

-

-
-				// Digital / Dual Shock Controller

-				if (buf[parp] == 0x41) {

-					switch (value) {

-						// enter config mode

-						case 0x43:

-							buf[1] = 0x43;

-							break;

-

-						// get status

-						case 0x45:

-							buf[1] = 0xf3;

-							break;

-					}

-				}

-

-

-				// NegCon - Wipeout 3

-				if( buf[parp] == 0x23 ) {

-					switch (value) {

-						// enter config mode

-						case 0x43:

-							buf[1] = 0x79;

-							break;

-

-						// get status

-						case 0x45:

-							buf[1] = 0xf3;

-							break;

-					}

-				}

+				}
+
+
+				// Digital / Dual Shock Controller
+				if (buf[parp] == 0x41) {
+					switch (value) {
+						// enter config mode
+						case 0x43:
+							buf[1] = 0x43;
+							break;
+
+						// get status
+						case 0x45:
+							buf[1] = 0xf3;
+							break;
+					}
+				}
+
+
+				// NegCon - Wipeout 3
+				if( buf[parp] == 0x23 ) {
+					switch (value) {
+						// enter config mode
+						case 0x43:
+							buf[1] = 0x79;
+							break;
+
+						// get status
+						case 0x45:
+							buf[1] = 0xf3;
+							break;
+					}
+				}
 			}
 			else padst = 0;
 			return;
@@ -225,9 +220,9 @@ void sioWrite8(unsigned char value) {
 				return;
 			}*/
 			if (!Config.UseNet) {
-				switch (CtrlReg & 0x2002) {
-					case 0x0002: buf[parp] = PAD1_poll(value); break;
-					case 0x2002: buf[parp] = PAD2_poll(value); break;
+				switch (CtrlReg & (DTR_PERM|DTR)) {
+					case DTR_PERM: buf[parp] = PAD1_poll(value); break;
+					case (DTR_PERM|DTR): buf[parp] = PAD2_poll(value); break;
 				}
 			}
 
@@ -272,11 +267,11 @@ void sioWrite8(unsigned char value) {
 					buf[1] = 0x5d;
 					buf[2] = adrH;
 					buf[3] = adrL;
-					switch (CtrlReg & 0x2002) {
-						case 0x0002:
+					switch (CtrlReg & (DTR_PERM|DTR)) {
+						case DTR_PERM:
 							memcpy(&buf[4], Mcd1Data + (adrL | (adrH << 8)) * 128, 128);
 							break;
-						case 0x2002:
+						case (DTR_PERM|DTR):
 							memcpy(&buf[4], Mcd2Data + (adrL | (adrH << 8)) * 128, 128);
 							break;
 					}
@@ -672,12 +667,12 @@ void sioWrite8(unsigned char value) {
 			StatReg |= RX_RDY;		// Transfer is Ready
 
 			if (!Config.UseNet) {
-				switch (CtrlReg & 0x2002) {
-					case 0x0002: buf[0] = PAD1_startPoll(1); break;
-					case 0x2002: buf[0] = PAD2_startPoll(2); break;
+				switch (CtrlReg & (DTR_PERM|DTR)) {
+					case DTR_PERM: buf[0] = PAD1_startPoll(1); break;
+					case (DTR_PERM|DTR): buf[0] = PAD2_startPoll(2); break;
 				}
 			} else {
-				if ((CtrlReg & 0x2002) == 0x0002) {
+				if ((CtrlReg & (DTR_PERM|DTR)) == DTR_PERM) {
 					int i, j;
 
 					PAD1_startPoll(1);
@@ -778,12 +773,12 @@ unsigned char sioRead8() {
 			if (mcdst == 5) {
 				mcdst = 0;
 				if (rdwr == 2) {
-					switch (CtrlReg & 0x2002) {
-						case 0x0002:
+					switch (CtrlReg & (DTR_PERM|DTR)) {
+						case DTR_PERM:
 							memcpy(Mcd1Data + (adrL | (adrH << 8)) * 128, &buf[1], 128);
 							SaveMcd(Config.Mcd1, Mcd1Data, (adrL | (adrH << 8)) * 128, 128);
 							break;
-						case 0x2002:
+						case (DTR_PERM|DTR):
 							memcpy(Mcd2Data + (adrL | (adrH << 8)) * 128, &buf[1], 128);
 							SaveMcd(Config.Mcd2, Mcd2Data, (adrL | (adrH << 8)) * 128, 128);
 							break;
@@ -805,20 +800,20 @@ unsigned char sioRead8() {
 }
 
 unsigned short sioReadStat16() {
-	u16 hard;

-

-	hard = StatReg;

-

-#if 0

-	// wait for IRQ first

-	if( psxRegs.interrupt & (1 << PSXINT_SIO) )

-	{

-		hard &= ~TX_RDY;

-		hard &= ~RX_RDY;

-		hard &= ~TX_EMPTY;

-	}

-#endif

-

+	u16 hard;
+
+	hard = StatReg;
+
+#if 0
+	// wait for IRQ first
+	if( psxRegs.interrupt & (1 << PSXINT_SIO) )
+	{
+		hard &= ~TX_RDY;
+		hard &= ~RX_RDY;
+		hard &= ~TX_EMPTY;
+	}
+#endif
+
 	return hard;
 }
 
@@ -885,7 +880,8 @@ void LoadMcd(int mcd, char *str) {
 				else if(buf.st_size == MCD_SIZE + 3904)
 					fseek(f, 3904, SEEK_SET);
 			}
-			fread(data, 1, MCD_SIZE, f);
+			if(fread(data, 1, MCD_SIZE, f) != MCD_SIZE)
+				perror(str);
 			fclose(f);
 		}
 		else
@@ -900,7 +896,8 @@ void LoadMcd(int mcd, char *str) {
 			else if(buf.st_size == MCD_SIZE + 3904)
 				fseek(f, 3904, SEEK_SET);
 		}
-		fread(data, 1, MCD_SIZE, f);
+		if(fread(data, 1, MCD_SIZE, f) != MCD_SIZE)
+			perror(str);
 		fclose(f);
 	}
 }
@@ -927,8 +924,10 @@ void SaveMcd(char *mcd, char *data, uint32_t adr, int size) {
 		} else
 			fseek(f, adr, SEEK_SET);
 
-		fwrite(data + adr, 1, size, f);
-		fclose(f);
+		if(fwrite(data + adr, 1, size, f) != size)
+			perror(mcd);
+		if(fclose(f) != 0)
+			perror(mcd);
 		return;
 	}
 
@@ -1108,7 +1107,8 @@ void ConvertMcd(char *mcd, char *data) {
 	if (strstr(mcd, ".gme")) {
 		f = fopen(mcd, "wb");
 		if (f != NULL) {
-			fwrite(data - 3904, 1, MCD_SIZE + 3904, f);
+			if(fwrite(data - 3904, MCD_SIZE + 3904, 1, f) != 1)
+				perror(mcd);
 			fclose(f);
 		}
 		f = fopen(mcd, "r+");
@@ -1142,8 +1142,10 @@ void ConvertMcd(char *mcd, char *data) {
 	} else if(strstr(mcd, ".mem") || strstr(mcd,".vgs")) {
 		f = fopen(mcd, "wb");
 		if (f != NULL) {
-			fwrite(data-64, 1, MCD_SIZE+64, f);
-			fclose(f);
+			if(fwrite(data-64, MCD_SIZE+64, 1, f) != 1)
+				perror(mcd);
+			if(fclose(f) != 0)
+				perror(mcd);;
 		}
 		f = fopen(mcd, "r+");
 		s = s + 64;
@@ -1164,14 +1166,16 @@ void ConvertMcd(char *mcd, char *data) {
 	} else {
 		f = fopen(mcd, "wb");
 		if (f != NULL) {
-			fwrite(data, 1, MCD_SIZE, f);
-			fclose(f);
+			if(fwrite(data, 1, MCD_SIZE, f) != MCD_SIZE)
+				perror(mcd);
+			if(fclose(f) != 0)
+				perror(mcd);
 		}
 	}
 }
 
 void GetMcdBlockInfo(int mcd, int block, McdBlock *Info) {
-	unsigned char *data = NULL, *ptr, *str, *sstr;
+	char *data = NULL, *ptr, *str, *sstr;
 	unsigned short clut[16];
 	unsigned short c;
 	int i, x;
@@ -1282,7 +1286,8 @@ void LoadDongle( char *str )
 	
 	f = fopen(str, "r+b");
 	if (f != NULL) {
-		fread( DongleData, 1, DONGLE_SIZE, f );
+		if(fread( DongleData, 1, DONGLE_SIZE, f ) != DONGLE_SIZE)
+			perror(str);
 		fclose( f );
 	}
 	else {
@@ -1318,7 +1323,9 @@ void SaveDongle( char *str )
 	
 	f = fopen(str, "wb");
 	if (f != NULL) {
-		fwrite( DongleData, 1, DONGLE_SIZE, f );
-		fclose( f );
+		if(fwrite( DongleData, 1, DONGLE_SIZE, f ) != DONGLE_SIZE)
+			perror(str);
+		if(fclose( f ) != 0)
+			perror(str);
 	}
 }
diff --git a/libpcsxcore/socket.c b/libpcsxcore/socket.c
index 2e0dc870..31f82e25 100644
--- a/libpcsxcore/socket.c
+++ b/libpcsxcore/socket.c
@@ -190,7 +190,7 @@ int ReadSocket(char * buffer, int len) {
 }
 
 int RawReadSocket(char * buffer, int len) {
-    int r;
+    int r = 0;
     int mlen = len < ptr ? len : ptr;
 
     if (!client_socket)