quick compile fix.

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

1 files changed, 409 insertions, 408 deletions

diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c
index c81097b5..f8f9da86 100644
--- a/libpcsxcore/cdrom.c
+++ b/libpcsxcore/cdrom.c
@@ -23,6 +23,7 @@
 
 #include "cdrom.h"
 #include "ppf.h"
+#include "psxdma.h"
 
 cdrStruct cdr;
 
@@ -103,12 +104,12 @@ static struct SubQ *subq;
 	psxRegs.intCycle[PSXINT_CDREAD].sCycle = psxRegs.cycle; \
 }
 
-#define CDREPPLAY_INT(eCycle) { \

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

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

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

-}

-

+#define CDREPPLAY_INT(eCycle) { \
+	psxRegs.interrupt |= (1 << PSXINT_CDREPPLAY); \
+	psxRegs.intCycle[PSXINT_CDREPPLAY].cycle = eCycle; \
+	psxRegs.intCycle[PSXINT_CDREPPLAY].sCycle = psxRegs.cycle; \
+}
+
 #define StartReading(type, eCycle) { \
    	cdr.Reading = type; \
   	cdr.FirstSector = 1; \
@@ -128,9 +129,9 @@ static struct SubQ *subq;
 	if (cdr.Play) { \
 		if (!Config.Cdda) CDR_stop(); \
 		cdr.StatP &= ~0x80; \
-		cdr.Play = FALSE; \

-		cdr.FastForward = 0; \

-		cdr.FastBackward = 0; \

+		cdr.Play = FALSE; \
+		cdr.FastForward = 0; \
+		cdr.FastBackward = 0; \
 	} \
 }
 
@@ -140,37 +141,37 @@ static struct SubQ *subq;
 	cdr.ResultReady = 1; \
 }
 
-void Find_CurTrack() {

-	cdr.CurTrack = 0;

-

-	if (CDR_getTN(cdr.ResultTN) != -1) {

-		int lcv;

-

-		for( lcv = 1; lcv < cdr.ResultTN[1]; lcv++ ) {

-			if (CDR_getTD((u8)(lcv), cdr.ResultTD) != -1) {

-				u32 sect1, sect2;

-

-#ifdef CDR_LOG___0

-				CDR_LOG( "curtrack %d %d %d | %d %d %d | %d\n",

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

-					cdr.ResultTD[0], cdr.ResultTD[1], cdr.ResultTD[2],

-					cdr.CurTrack );

-#endif

-

-				// find next track boundary

-				sect1 = cdr.SetSectorPlay[0] * 60 * 75 + cdr.SetSectorPlay[1] * 75 + cdr.SetSectorPlay[2];

-				sect2 = cdr.ResultTD[2] * 60 * 75 + cdr.ResultTD[1] * 75 + cdr.ResultTD[0];

-				if( sect1 >= sect2 ) {

-					cdr.CurTrack++;

-					continue;

-				}

-			}

-

-			break;

-		}

-	}

-}

-

+void Find_CurTrack() {
+	cdr.CurTrack = 0;
+
+	if (CDR_getTN(cdr.ResultTN) != -1) {
+		int lcv;
+
+		for( lcv = 1; lcv < cdr.ResultTN[1]; lcv++ ) {
+			if (CDR_getTD((u8)(lcv), cdr.ResultTD) != -1) {
+				u32 sect1, sect2;
+
+#ifdef CDR_LOG___0
+				CDR_LOG( "curtrack %d %d %d | %d %d %d | %d\n",
+					cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2],
+					cdr.ResultTD[0], cdr.ResultTD[1], cdr.ResultTD[2],
+					cdr.CurTrack );
+#endif
+
+				// find next track boundary
+				sect1 = cdr.SetSectorPlay[0] * 60 * 75 + cdr.SetSectorPlay[1] * 75 + cdr.SetSectorPlay[2];
+				sect2 = cdr.ResultTD[2] * 60 * 75 + cdr.ResultTD[1] * 75 + cdr.ResultTD[0];
+				if( sect1 >= sect2 ) {
+					cdr.CurTrack++;
+					continue;
+				}
+			}
+
+			break;
+		}
+	}
+}
+
 static void ReadTrack() {
 	cdr.Prev[0] = itob(cdr.SetSector[0]);
 	cdr.Prev[1] = itob(cdr.SetSector[1]);
@@ -199,94 +200,94 @@ void AddIrqQueue(unsigned char irq, unsigned long ecycle) {
 	}
 }
 
-void cdrRepplayInterrupt()

-{

-	// Wait for IRQ to be acknowledged

-	if (cdr.Stat) {

-		CDREAD_INT(0x1000);

-		return;

-	}

-

-#ifdef CDR_LOG

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

-#endif

-

-	if ((cdr.Mode & 5) != 5) return;

-

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

-	if( CDR_getStatus(&stat) != -1) {

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

-		static u8 report_time = 1;

-

-

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

-

-		if (subq != NULL ) {

-#ifdef CDR_LOG

-			CDR_LOG( "REPPLAY IRQ - %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) )

-

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

-

-

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

-			}

-		}

-	}

-

-	// Rayman: Logo freeze

-	cdr.ResultReady = 1;

-

-	cdr.Stat = DataReady;

-	SetResultSize(8);

-

-

-	// Wild 9: Do not use REPPLAY_ACK

-	// - must use faster times for reporting

-	CDREPPLAY_INT(cdReadTime / 2);

-

-

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

-	psxRegs.interrupt |= 0x80000000;

-}

-

+void cdrRepplayInterrupt()
+{
+	// Wait for IRQ to be acknowledged
+	if (cdr.Stat) {
+		CDREAD_INT(0x1000);
+		return;
+	}
+
+#ifdef CDR_LOG
+	CDR_LOG("cdrRepplayInterrupt() Log: KEY END\n");
+#endif
+
+	if ((cdr.Mode & 5) != 5) return;
+
+	memset( cdr.Result, 0, 8 );
+	if( CDR_getStatus(&stat) != -1) {
+		// BIOS - HACK: Switch between local / absolute times
+		static u8 report_time = 1;
+
+
+		subq = (struct SubQ *)CDR_getBufferSub();
+
+		if (subq != NULL ) {
+#ifdef CDR_LOG
+			CDR_LOG( "REPPLAY IRQ - %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) )
+
+			cdr.Result[0] = cdr.StatP;
+
+
+			// 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;
+			}
+		}
+	}
+
+	// Rayman: Logo freeze
+	cdr.ResultReady = 1;
+
+	cdr.Stat = DataReady;
+	SetResultSize(8);
+
+
+	// Wild 9: Do not use REPPLAY_ACK
+	// - must use faster times for reporting
+	CDREPPLAY_INT(cdReadTime / 2);
+
+
+	psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+	psxRegs.interrupt |= 0x80000000;
+}
+
 void cdrInterrupt() {
 	int i;
 	unsigned char Irq = cdr.Irq;
@@ -329,11 +330,11 @@ void cdrInterrupt() {
 			cdr.Result[0] = cdr.StatP;
 			cdr.Stat = Acknowledge;
 			cdr.StatP |= 0x80;
-			

-			// Lemmings: report play times

-			if ((cdr.Mode & 0x5) == 0x5) {

-				CDREPPLAY_INT( cdReadTime );

-			}

+			
+			// Lemmings: report play times
+			if ((cdr.Mode & 0x5) == 0x5) {
+				CDREPPLAY_INT( cdReadTime );
+			}
 			break;
 
     	case CdlForward:
@@ -342,13 +343,13 @@ void cdrInterrupt() {
 			cdr.StatP |= 0x2;
      	cdr.Result[0] = cdr.StatP;
      	cdr.Stat = Complete;
-

-

-			// GameShark CD Player: Calls 2x + Play 2x

-			if( cdr.FastForward == 0 ) cdr.FastForward = 2;

-			else cdr.FastForward++;

-

-			cdr.FastBackward = 0;

+
+
+			// GameShark CD Player: Calls 2x + Play 2x
+			if( cdr.FastForward == 0 ) cdr.FastForward = 2;
+			else cdr.FastForward++;
+
+			cdr.FastBackward = 0;
 			break;
 
     	case CdlBackward:
@@ -356,14 +357,14 @@ void cdrInterrupt() {
 			SetResultSize(1);
 			cdr.StatP |= 0x2;
       cdr.Result[0] = cdr.StatP;
-      cdr.Stat = Complete;

-

-

-			// GameShark CD Player: Calls 2x + Play 2x

-			if( cdr.FastBackward == 0 ) cdr.FastBackward = 2;

-			else cdr.FastBackward++;

-

-			cdr.FastForward = 0;

+      cdr.Stat = Complete;
+
+
+			// GameShark CD Player: Calls 2x + Play 2x
+			if( cdr.FastBackward == 0 ) cdr.FastBackward = 2;
+			else cdr.FastBackward++;
+
+			cdr.FastForward = 0;
 			break;
 
     	case CdlStandby:
@@ -467,19 +468,19 @@ void cdrInterrupt() {
         	break;
 
 		case CdlGetlocP:
-			// GameShark CDX CD Player: uses 17 bytes output (wraps around)

-			SetResultSize(17);

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

-

+			// GameShark CDX CD Player: uses 17 bytes output (wraps around)
+			SetResultSize(17);
+			memset( cdr.Result, 0, 16 );
+
 			subq = (struct SubQ *)CDR_getBufferSub();
 
 			if (subq != NULL) {
-				cdr.Result[0] = subq->TrackNumber;

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

-				memcpy(cdr.Result+2, subq->TrackRelativeAddress, 3);

-				memcpy(cdr.Result+5, subq->AbsoluteAddress, 3);

-

-

+				cdr.Result[0] = subq->TrackNumber;
+				cdr.Result[1] = subq->IndexNumber;
+				memcpy(cdr.Result+2, subq->TrackRelativeAddress, 3);
+				memcpy(cdr.Result+5, subq->AbsoluteAddress, 3);
+
+
 				// subQ integrity check
 				if (calcCrc((u8 *)subq + 12, 10) != (((u16)subq->CRC[0] << 8) | subq->CRC[1])) {
 					memset(cdr.Result + 2, 0, 3 + 3); // CRC wrong, wipe out time data
@@ -505,55 +506,55 @@ void cdrInterrupt() {
 				memcpy(cdr.Result + 5, cdr.Prev, 3);
 			}
 
-#if 1

-			// FIXME!!!

-			if( cdr.LidCheck > 0 ) {

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

-

-				// each state needs ~50 tries

-				if( cdr.LidCheck < 130 )

-					cdr.LidCheck++;

-				else

-					cdr.LidCheck = 0;

-

-				i = stat.Status;

-				if (CDR_getStatus(&stat) != -1) {

-					// Hack: Fake CDROM seek / spin time

-					static int seek_time = 0;

-

-					if (stat.Type == 0xff) {

-					}

-					else if (stat.Status & 0x10) {

-						// unknown #1 - status?

-						// unknown #2 - case open?

-

-						cdr.Result[0] = 0x11;

-						cdr.Result[1] = 0x80;

-					}

-					else if ( i & 0x10 ) {

-						cdr.Result[0] = 0x13;

-						cdr.Result[1] = 0x80;

-

-						// minimum tries for GS CDX 3.3

-						seek_time = 120;

-					}

-					else if ( seek_time > 60 ) {

-						cdr.Result[0] = 0x13;

-						cdr.Result[1] = 0x80;

-

-						seek_time--;

-					}

-					else if( seek_time ) {

-						// GameShark CDX swap

-						cdr.Result[0] = 0x01;

-						cdr.Result[1] = 0x00;

-

-						seek_time--;

-					}

-				}

-			}

-#endif

-

+#if 1
+			// FIXME!!!
+			if( cdr.LidCheck > 0 ) {
+				memset( cdr.Result, 0, 16 );
+
+				// each state needs ~50 tries
+				if( cdr.LidCheck < 130 )
+					cdr.LidCheck++;
+				else
+					cdr.LidCheck = 0;
+
+				i = stat.Status;
+				if (CDR_getStatus(&stat) != -1) {
+					// Hack: Fake CDROM seek / spin time
+					static int seek_time = 0;
+
+					if (stat.Type == 0xff) {
+					}
+					else if (stat.Status & 0x10) {
+						// unknown #1 - status?
+						// unknown #2 - case open?
+
+						cdr.Result[0] = 0x11;
+						cdr.Result[1] = 0x80;
+					}
+					else if ( i & 0x10 ) {
+						cdr.Result[0] = 0x13;
+						cdr.Result[1] = 0x80;
+
+						// minimum tries for GS CDX 3.3
+						seek_time = 120;
+					}
+					else if ( seek_time > 60 ) {
+						cdr.Result[0] = 0x13;
+						cdr.Result[1] = 0x80;
+
+						seek_time--;
+					}
+					else if( seek_time ) {
+						// GameShark CDX swap
+						cdr.Result[0] = 0x01;
+						cdr.Result[1] = 0x00;
+
+						seek_time--;
+					}
+				}
+			}
+#endif
+
 			cdr.Stat = Acknowledge;
 			break;
 
@@ -625,9 +626,9 @@ void cdrInterrupt() {
 			cdr.StatP &= ~0x40;
 			cdr.Result[0] = cdr.StatP;
 			cdr.Stat = Complete;
-			

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

-			ReadTrack();

+			
+			// Tomb Raider 2: must update read cursor for getlocp
+			ReadTrack();
 			break;
 
 		case CdlTest:
@@ -657,26 +658,26 @@ void cdrInterrupt() {
 			break;
 
 		case CdlID + 0x20:
-			SetResultSize(8);

-			if (CDR_getStatus(&stat) == -1) {

-				cdr.Result[0] = 0x00; // 0x08 and cdr.Result[1]|0x10 : audio cd, enters cd player

-				cdr.Result[1] = 0x00; // 0x80 leads to the menu in the bios, else loads CD

-			}

-			else {

-				if (stat.Type == 2) {

-					// Music CD

-					cdr.Result[0] = 0x08;

-					cdr.Result[1] = 0x10;

-						

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

-				}

-				else {

-					// Data CD

-					cdr.Result[0] = 0x08;

-					cdr.Result[1] = 0x00;

-				}

-			}

-

+			SetResultSize(8);
+			if (CDR_getStatus(&stat) == -1) {
+				cdr.Result[0] = 0x00; // 0x08 and cdr.Result[1]|0x10 : audio cd, enters cd player
+				cdr.Result[1] = 0x00; // 0x80 leads to the menu in the bios, else loads CD
+			}
+			else {
+				if (stat.Type == 2) {
+					// Music CD
+					cdr.Result[0] = 0x08;
+					cdr.Result[1] = 0x10;
+						
+					cdr.Result[1] |= 0x80;
+				}
+				else {
+					// Data CD
+					cdr.Result[0] = 0x08;
+					cdr.Result[1] = 0x00;
+				}
+			}
+
 			cdr.Result[1] |= 0x80;
 			cdr.Result[2] = 0x00;
 			cdr.Result[3] = 0x00;
@@ -718,7 +719,7 @@ void cdrInterrupt() {
     		cdr.Stat = DataEnd;
 */			AddIrqQueue(CdlPause, 0x800);
 			break;
-

+
 		case READ_ACK:
 			if (!cdr.Reading) return;
 
@@ -745,7 +746,7 @@ void cdrInterrupt() {
 	}
 
 	// check case open/close
-	if( cdr.LidCheck > 0 && Irq != CdlGetlocP ) {

+	if( cdr.LidCheck > 0 && Irq != CdlGetlocP ) {
 	// if (cdr.LidCheck > 0) {
 		cdr.LidCheck--;
 
@@ -850,11 +851,11 @@ void cdrReadInterrupt() {
 #endif
 
 	if ((!cdr.Muted) && (cdr.Mode & 0x40) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
-		// Firemen 2: Multi-XA files - briefings, cutscenes

-		if( cdr.FirstSector == 1 && (cdr.Mode & 0x8)==0 ) {

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

-		}

-

+		// Firemen 2: Multi-XA files - briefings, cutscenes
+		if( cdr.FirstSector == 1 && (cdr.Mode & 0x8)==0 ) {
+			cdr.File = cdr.Transfer[4 + 0];
+		}
+
 		if ((cdr.Transfer[4 + 2] & 0x4) &&
 			((cdr.Mode & 0x8) ? (cdr.Transfer[4 + 1] == cdr.Channel) : 1) &&
 			(cdr.Transfer[4 + 0] == cdr.File)) {
@@ -890,17 +891,17 @@ void cdrReadInterrupt() {
 	else {
 		CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
 	}
-

-	/*

-	Judge Dredd: don't return FORM2 during ADPCM playback (movie playing)

-

-	Xenogears: use correct FORM2 ID ($64 / $E4 for movies)

-	*/

-	if( (cdr.Mode & 0x40) == 0 || (cdr.Transfer[4+2] & 0x64) != 0x64 ) {

-		cdr.Stat = DataReady;

-

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

-	}

+
+	/*
+	Judge Dredd: don't return FORM2 during ADPCM playback (movie playing)
+
+	Xenogears: use correct FORM2 ID ($64 / $E4 for movies)
+	*/
+	if( (cdr.Mode & 0x40) == 0 || (cdr.Transfer[4+2] & 0x64) != 0x64 ) {
+		cdr.Stat = DataReady;
+
+		psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+	}
 }
 
 /*
@@ -956,9 +957,9 @@ void cdrWrite0(unsigned char rt) {
 
 unsigned char cdrRead1(void) {
   if (cdr.ResultReady) { // && cdr.Ctrl & 0x1) {
-		// GameShark CDX CD Player: uses 17 bytes output (wraps around)

-		psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];

-		cdr.ResultP++;

+		// GameShark CDX CD Player: uses 17 bytes output (wraps around)
+		psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];
+		cdr.ResultP++;
 		if (cdr.ResultP == cdr.ResultC)
 			cdr.ResultReady = 0;
 	} else {
@@ -1013,102 +1014,102 @@ void cdrWrite1(unsigned char rt) {
         for (i = 0; i < 3; i++)
 					cdr.SetSector[i] = btoi(cdr.Param[i]);
         cdr.SetSector[3] = 0;
-

-#ifdef DVD5_HACK

-				// PS1 DVD5 hack (shalma's disc combining kits)

-				dvd5_mode = cdr.Param[2] & 0x80;

-				

-				if( CDR__setDVD5 ) {

-					if( cdr.Param[2] & 0x80 )

-						CDR__setDVD5(1);

-					else if( cdr.Param[1] & 0x80 )

-						CDR__setDVD5(2);

-					else

-						CDR__setDVD5(0);

-				}

-

-				cdr.Param[1] &= 0x7f;

-				cdr.Param[2] &= 0x7f;

-#endif

-

-				// GameShark Music Player

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

-

-

-				/*

+
+#ifdef DVD5_HACK
+				// PS1 DVD5 hack (shalma's disc combining kits)
+				dvd5_mode = cdr.Param[2] & 0x80;
+				
+				if( CDR__setDVD5 ) {
+					if( cdr.Param[2] & 0x80 )
+						CDR__setDVD5(1);
+					else if( cdr.Param[1] & 0x80 )
+						CDR__setDVD5(2);
+					else
+						CDR__setDVD5(0);
+				}
+
+				cdr.Param[1] &= 0x7f;
+				cdr.Param[2] &= 0x7f;
+#endif
+
+				// GameShark Music Player
+				memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 );
+
+
+				/*
 				if ((cdr.SetSector[0] | cdr.SetSector[1] | cdr.SetSector[2]) == 0) {
 					*(u32 *)cdr.SetSector = *(u32 *)cdr.SetSectorSeek;
 				}*/
-				

+				
 				cdr.Ctrl |= 0x80;
         cdr.Stat = NoIntr;
     		AddIrqQueue(cdr.Cmd, 0x1000);
         break;
 
     	case CdlPlay:
-				// Rayman: detect track changes

-				Find_CurTrack();

-

-

-				// GameShark CD Player: Calls 2x + Play 2x

-				if( cdr.FastBackward || cdr.FastForward ) {

-					if( cdr.FastForward ) cdr.FastForward--;

-					if( cdr.FastBackward ) cdr.FastBackward--;

-

-					if( cdr.FastBackward == 0 && cdr.FastForward == 0 ) {

-						if( cdr.Play && CDR_getStatus(&stat) != -1 ) {

-							cdr.SetSectorPlay[0] = stat.Time[0];

-							cdr.SetSectorPlay[1] = stat.Time[1];

-							cdr.SetSectorPlay[2] = stat.Time[2];

-						}

-					}

-				}

-

-

-				if (!Config.Cdda) {

-					// BIOS CD Player

-					// - Pause player, hit Track 01/02/../xx (Setloc issued!!)

-

-					// GameShark CD Player: Resume play

-					if( cdr.ParamC == 0 ) {

-						CDR_play( cdr.SetSectorPlay );

-					}

-					else

-					{

-						// BIOS CD Player: Resume play

-						if( cdr.Param[0] == 0 ) {

-							CDR_play( cdr.SetSectorPlay );

-						}

-

-						else {

-							// BIOS CD Player: Allow track replaying

-							StopCdda();

-

-

-							cdr.CurTrack = btoi( cdr.Param[0] );

-

-							if (CDR_getTN(cdr.ResultTN) != -1) {

-								// check last track

-								if (cdr.CurTrack > cdr.ResultTN[1])

-									cdr.CurTrack = cdr.ResultTN[1];

-

-								if (CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD) != -1) {

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

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

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

-

-									CDR_play(cdr.SetSectorPlay);

-								}

-							}

-						}

-					}

-				}

-

-				cdr.Play = TRUE;

-				cdr.Ctrl |= 0x80;

-				cdr.Stat = NoIntr; 

-				AddIrqQueue(cdr.Cmd, 0x1000);

-				break;

+				// Rayman: detect track changes
+				Find_CurTrack();
+
+
+				// GameShark CD Player: Calls 2x + Play 2x
+				if( cdr.FastBackward || cdr.FastForward ) {
+					if( cdr.FastForward ) cdr.FastForward--;
+					if( cdr.FastBackward ) cdr.FastBackward--;
+
+					if( cdr.FastBackward == 0 && cdr.FastForward == 0 ) {
+						if( cdr.Play && CDR_getStatus(&stat) != -1 ) {
+							cdr.SetSectorPlay[0] = stat.Time[0];
+							cdr.SetSectorPlay[1] = stat.Time[1];
+							cdr.SetSectorPlay[2] = stat.Time[2];
+						}
+					}
+				}
+
+
+				if (!Config.Cdda) {
+					// BIOS CD Player
+					// - Pause player, hit Track 01/02/../xx (Setloc issued!!)
+
+					// GameShark CD Player: Resume play
+					if( cdr.ParamC == 0 ) {
+						CDR_play( cdr.SetSectorPlay );
+					}
+					else
+					{
+						// BIOS CD Player: Resume play
+						if( cdr.Param[0] == 0 ) {
+							CDR_play( cdr.SetSectorPlay );
+						}
+
+						else {
+							// BIOS CD Player: Allow track replaying
+							StopCdda();
+
+
+							cdr.CurTrack = btoi( cdr.Param[0] );
+
+							if (CDR_getTN(cdr.ResultTN) != -1) {
+								// check last track
+								if (cdr.CurTrack > cdr.ResultTN[1])
+									cdr.CurTrack = cdr.ResultTN[1];
+
+								if (CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD) != -1) {
+									cdr.SetSectorPlay[0] = cdr.ResultTD[2];
+									cdr.SetSectorPlay[1] = cdr.ResultTD[1];
+									cdr.SetSectorPlay[2] = cdr.ResultTD[0];
+
+									CDR_play(cdr.SetSectorPlay);
+								}
+							}
+						}
+					}
+				}
+
+				cdr.Play = TRUE;
+				cdr.Ctrl |= 0x80;
+				cdr.Stat = NoIntr; 
+				AddIrqQueue(cdr.Cmd, 0x1000);
+				break;
 
     	case CdlForward:
         //if (cdr.CurTrack < 0xaa)
@@ -1143,46 +1144,46 @@ void cdrWrite1(unsigned char rt) {
         	break;
 
     	case CdlStop:
-				// GameShark CD Player: Reset CDDA to track start

-				if( cdr.Play && CDR_getStatus(&stat) != -1 ) {

-					cdr.SetSectorPlay[0] = stat.Time[0];

-					cdr.SetSectorPlay[1] = stat.Time[1];

-					cdr.SetSectorPlay[2] = stat.Time[2];

-

-					Find_CurTrack();

-

-

-					// grab time for current track

-					CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);

-

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

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

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

-				}

-

-				StopCdda();

-				StopReading();

-

+				// GameShark CD Player: Reset CDDA to track start
+				if( cdr.Play && CDR_getStatus(&stat) != -1 ) {
+					cdr.SetSectorPlay[0] = stat.Time[0];
+					cdr.SetSectorPlay[1] = stat.Time[1];
+					cdr.SetSectorPlay[2] = stat.Time[2];
+
+					Find_CurTrack();
+
+
+					// grab time for current track
+					CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);
+
+					cdr.SetSectorPlay[0] = cdr.ResultTD[2];
+					cdr.SetSectorPlay[1] = cdr.ResultTD[1];
+					cdr.SetSectorPlay[2] = cdr.ResultTD[0];
+				}
+
+				StopCdda();
+				StopReading();
+
 				cdr.Ctrl |= 0x80;
     		cdr.Stat = NoIntr;
     		AddIrqQueue(cdr.Cmd, 0x1000);
        	break;
 
     	case CdlPause:
-				/*

-				GameShark CD Player: save time for resume

-				

-				Twisted Metal - World Tour: don't save times for DATA reads

-				- Only get 1 chance to do this right

-				*/

-				if( cdr.Play && CDR_getStatus(&stat) != -1 ) {

-					cdr.SetSectorPlay[0] = stat.Time[0];

-					cdr.SetSectorPlay[1] = stat.Time[1];

-					cdr.SetSectorPlay[2] = stat.Time[2];

-				}

-

-				StopCdda();

-				StopReading();

+				/*
+				GameShark CD Player: save time for resume
+				
+				Twisted Metal - World Tour: don't save times for DATA reads
+				- Only get 1 chance to do this right
+				*/
+				if( cdr.Play && CDR_getStatus(&stat) != -1 ) {
+					cdr.SetSectorPlay[0] = stat.Time[0];
+					cdr.SetSectorPlay[1] = stat.Time[1];
+					cdr.SetSectorPlay[2] = stat.Time[2];
+				}
+
+				StopCdda();
+				StopReading();
 				cdr.Ctrl |= 0x80;
     		cdr.Stat = NoIntr;
     		AddIrqQueue(cdr.Cmd, 0x80000);
@@ -1245,19 +1246,19 @@ void cdrWrite1(unsigned char rt) {
 				cdr.Ctrl |= 0x80;
 	  		cdr.Stat = NoIntr; 
 				AddIrqQueue(cdr.Cmd, 0x1000);
-

-				// GameShark CDX / Lite Player: pretty narrow time window

-				// - doesn't always work due to time inprecision

-				//AddIrqQueue(cdr.Cmd, 0x28);

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

-				// GameShark CDX CD Player: very long time

-				AddIrqQueue(cdr.Cmd, 0x100000);

+
+				// GameShark CDX CD Player: very long time
+				AddIrqQueue(cdr.Cmd, 0x100000);
         break;
 
     	case CdlGetTD:
@@ -1373,38 +1374,38 @@ unsigned char cdrRead3(void) {
 void cdrWrite3(unsigned char rt) {
 #ifdef CDR_LOG
 	CDR_LOG("cdrWrite3() Log: CD3 write: %x\n", rt);
-#endif

-
-	// GameShark CDX CD Player: Irq timing mania

-	if( rt == 0 &&

-			cdr.Irq != 0 && cdr.Irq != 0xff &&

-			cdr.ResultReady == 0 ) {

-

-		// GS CDX: ~0x28 cycle timing - way too precise

-		if( cdr.Irq == CdlGetlocP ) {

-			cdrInterrupt();

-

-			psxRegs.interrupt &= ~(1 << PSXINT_CDR);

-		}

-	}

-

-

+#endif
+
+	// GameShark CDX CD Player: Irq timing mania
+	if( rt == 0 &&
+			cdr.Irq != 0 && cdr.Irq != 0xff &&
+			cdr.ResultReady == 0 ) {
+
+		// GS CDX: ~0x28 cycle timing - way too precise
+		if( cdr.Irq == CdlGetlocP ) {
+			cdrInterrupt();
+
+			psxRegs.interrupt &= ~(1 << PSXINT_CDR);
+		}
+	}
+
+
   if (rt == 0x07 && cdr.Ctrl & 0x1) {
 		cdr.Stat = 0;
 
 		if (cdr.Irq == 0xff) {
 			cdr.Irq = 0;
 			return;
-		}

+		}
 
 		if (cdr.Irq)
-			CDR_INT(cdr.eCycle);

+			CDR_INT(cdr.eCycle);
 
 		if (cdr.Reading && !cdr.ResultReady) 
             CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
 
 		return;
-	}

+	}
 
 	if (rt == 0x80 && !(cdr.Ctrl & 0x1) && cdr.Readed == 0) {
 		cdr.Readed = 1;
@@ -1467,11 +1468,11 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 			}
 
 			psxCpu->Clear(madr, cdsize / 4);
-			cdr.pTransfer += cdsize;

+			cdr.pTransfer += cdsize;
+
+			CDRDMA_INT( cdsize / 4 );
+			return;
 
-			CDRDMA_INT( cdsize / 4 );

-			return;

-

 		default:
 #ifdef CDR_LOG
 			CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
@@ -1483,12 +1484,12 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 	DMA_INTERRUPT(3);
 }
 
-void cdrDmaInterrupt()

-{

-	HW_DMA3_CHCR &= SWAP32(~0x01000000);

-	DMA_INTERRUPT(3);

-}

-

+void cdrDmaInterrupt()
+{
+	HW_DMA3_CHCR &= SWAP32(~0x01000000);
+	DMA_INTERRUPT(3);
+}
+
 void cdrReset() {
 	memset(&cdr, 0, sizeof(cdr));
 	cdr.CurTrack = 1;