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

2 files changed, 704 insertions, 704 deletions

diff --git a/libpcsxcore/cdriso.c b/libpcsxcore/cdriso.c
index 5bef990a..0e7b4bb1 100644
--- a/libpcsxcore/cdriso.c
+++ b/libpcsxcore/cdriso.c
@@ -132,11 +132,11 @@ static long GetTickCount(void) {
 }
 #endif
 
-

-u16 *iso_play_cdbuf;

-u16 iso_play_bufptr;

-

-

+
+u16 *iso_play_cdbuf;
+u16 iso_play_bufptr;
+
+
 // this thread plays audio data
 #ifdef _WIN32
 static void playthread(void *param)
@@ -145,14 +145,14 @@ static void *playthread(void *param)
 #endif
 {
 	long			d, t, i, s;
-	unsigned char	tmp;

+	unsigned char	tmp;
 	int sec;
 
 	t = GetTickCount();
 
-	iso_play_cdbuf = 0;

-	iso_play_bufptr = 0;

-

+	iso_play_cdbuf = 0;
+	iso_play_bufptr = 0;
+
 	while (playing) {
 		d = t - (long)GetTickCount();
 		if (d <= 0) {
@@ -187,8 +187,8 @@ static void *playthread(void *param)
 		else {
 			s = fread(sndbuffer, 1, sizeof(sndbuffer), cddaHandle);
 
-			sec = cddaCurOffset / CD_FRAMESIZE_RAW;

-

+			sec = cddaCurOffset / CD_FRAMESIZE_RAW;
+
 			if (subHandle != NULL) {
 				fseek(subHandle, sec * SUB_FRAMESIZE, SEEK_SET);
 				fread(subbuffer, 1, SUB_FRAMESIZE, subHandle);
@@ -212,59 +212,59 @@ static void *playthread(void *param)
 				}
 			}
 
-			// wipe data track

-			if( subHandle || subChanMixed ) {

-				if( ti[ ((struct SubQ *) subbuffer)->TrackNumber ].type == DATA )

-					memset( sndbuffer, 0, s );

-			}

-

+			// wipe data track
+			if( subHandle || subChanMixed ) {
+				if( ti[ ((struct SubQ *) subbuffer)->TrackNumber ].type == DATA )
+					memset( sndbuffer, 0, s );
+			}
+
 			SPU_playCDDAchannel((short *)sndbuffer, s);
 		}
-

+
 
 		cddaCurOffset += s;
-

-	

-		// BIOS CD Player: Fast forward / reverse seek

-		if( cdr.FastForward ) {

-			// ~+0.25 sec

-			cddaCurOffset += CD_FRAMESIZE_RAW * 75 * 3;

-

-#if 0

-			// Bad idea: too much static

-			if( subChanInterleaved )

-				fseek( cddaHandle, s * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE), SEEK_SET );

-			else

-				fseek( cddaHandle, s * CD_FRAMESIZE_RAW, SEEK_SET );

-#endif

-		}

-		else if( cdr.FastBackward ) {

-			// ~-0.25 sec

-			cddaCurOffset -= CD_FRAMESIZE_RAW * 75 * 3;

-			if( cddaCurOffset & 0x80000000 ) {

-				cddaCurOffset = 0;

-				cdr.FastBackward = 0;

-

-				playing = 0;

-				fclose(cddaHandle);

-				cddaHandle = NULL;

-				initial_offset = 0;

-				break;

-			}

-

-#if 0

-			// Bad idea: too much static

-			if( subChanInterleaved )

-				fseek( cddaHandle, s * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE), SEEK_SET );

-			else

-				fseek( cddaHandle, s * CD_FRAMESIZE_RAW, SEEK_SET );

-#endif

-		}

-

-	

-		// Vib Ribbon: decoded buffer IRQ

-		iso_play_cdbuf = sndbuffer;

-		iso_play_bufptr = 0;

+
+	
+		// BIOS CD Player: Fast forward / reverse seek
+		if( cdr.FastForward ) {
+			// ~+0.25 sec
+			cddaCurOffset += CD_FRAMESIZE_RAW * 75 * 3;
+
+#if 0
+			// Bad idea: too much static
+			if( subChanInterleaved )
+				fseek( cddaHandle, s * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE), SEEK_SET );
+			else
+				fseek( cddaHandle, s * CD_FRAMESIZE_RAW, SEEK_SET );
+#endif
+		}
+		else if( cdr.FastBackward ) {
+			// ~-0.25 sec
+			cddaCurOffset -= CD_FRAMESIZE_RAW * 75 * 3;
+			if( cddaCurOffset & 0x80000000 ) {
+				cddaCurOffset = 0;
+				cdr.FastBackward = 0;
+
+				playing = 0;
+				fclose(cddaHandle);
+				cddaHandle = NULL;
+				initial_offset = 0;
+				break;
+			}
+
+#if 0
+			// Bad idea: too much static
+			if( subChanInterleaved )
+				fseek( cddaHandle, s * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE), SEEK_SET );
+			else
+				fseek( cddaHandle, s * CD_FRAMESIZE_RAW, SEEK_SET );
+#endif
+		}
+
+	
+		// Vib Ribbon: decoded buffer IRQ
+		iso_play_cdbuf = sndbuffer;
+		iso_play_bufptr = 0;
 	}
 
 #ifdef _WIN32
@@ -695,7 +695,7 @@ static int opensubfile(const char *isoname) {
 	return 0;
 }
 
-static long CALLBACK ISOinit(void) {
+long CALLBACK ISOinit(void) {
 	assert(cdHandle == NULL);
 	assert(subHandle == NULL);
 
@@ -750,12 +750,12 @@ static long CALLBACK ISOopen(void) {
 	else if (parsemds(GetIsoFile()) == 0) {
 		SysPrintf("[+mds]");
 	}
-	else if (parsecue(GetIsoFile()) == 0) {

-		SysPrintf("[+cue]");

-	}

-	else if (parsetoc(GetIsoFile()) == 0) {

-		SysPrintf("[+toc]");

-	}

+	else if (parsecue(GetIsoFile()) == 0) {
+		SysPrintf("[+cue]");
+	}
+	else if (parsetoc(GetIsoFile()) == 0) {
+		SysPrintf("[+toc]");
+	}
 
 	if (!subChanMixed && opensubfile(GetIsoFile()) == 0) {
 		SysPrintf("[+sub]");
@@ -919,22 +919,22 @@ static unsigned char* CALLBACK ISOgetBufferSub(void) {
 }
 
 static long CALLBACK ISOgetStatus(struct CdrStat *stat) {
-	u32 sect;

-	

-	CDR__getStatus(stat);

-	

-	if (playing) {

-		stat->Status |= 0x80;

-	}

-	

-	// relative -> absolute time

-	sect = cddaCurOffset / CD_FRAMESIZE_RAW + 150;

-	sec2msf(sect, (u8 *)stat->Time);

-	

-	// BIOS - boot ID (CD type)

-	stat->Type = ti[1].type;

-	

-	return 0;

+	u32 sect;
+	
+	CDR__getStatus(stat);
+	
+	if (playing) {
+		stat->Status |= 0x80;
+	}
+	
+	// relative -> absolute time
+	sect = cddaCurOffset / CD_FRAMESIZE_RAW + 150;
+	sec2msf(sect, (u8 *)stat->Time);
+	
+	// BIOS - boot ID (CD type)
+	stat->Type = ti[1].type;
+	
+	return 0;
 }
 
 void cdrIsoInit(void) {
diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c
index 7210d778..cec02b57 100644
--- a/libpcsxcore/cdrom.c
+++ b/libpcsxcore/cdrom.c
@@ -84,6 +84,14 @@ unsigned char Test20[] = { 0x98, 0x06, 0x10, 0xC3 };
 unsigned char Test22[] = { 0x66, 0x6F, 0x72, 0x20, 0x45, 0x75, 0x72, 0x6F };
 unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 
+// cdr.Stat:
+#define NoIntr		0
+#define DataReady	1
+#define Complete	2
+#define Acknowledge	3
+#define DataEnd		4
+#define DiskError	5
+
 // 1x = 75 sectors per second
 // PSXCLK = 1 sec in the ps
 // so (PSXCLK / 75) = cdr read time (linuzappz)
@@ -91,21 +99,21 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 
 static struct CdrStat stat;
 static struct SubQ *subq;
-

-
-extern u16 *iso_play_cdbuf;

-extern u16 iso_play_bufptr;

-extern long CALLBACK ISOinit(void);

-extern void CALLBACK SPUirq(void);

-extern SPUregisterCallback SPU_registerCallback;

-

-#define H_SPUirqAddr		0x1f801da4

-#define H_SPUaddr				0x1f801da6

-#define H_SPUctrl				0x1f801daa

-#define H_CDLeft				0x1f801db0

-#define H_CDRight				0x1f801db2

-

-

+
+
+extern u16 *iso_play_cdbuf;
+extern u16 iso_play_bufptr;
+extern long CALLBACK ISOinit(void);
+extern void CALLBACK SPUirq(void);
+extern SPUregisterCallback SPU_registerCallback;
+
+#define H_SPUirqAddr		0x1f801da4
+#define H_SPUaddr				0x1f801da6
+#define H_SPUctrl				0x1f801daa
+#define H_CDLeft				0x1f801db0
+#define H_CDRight				0x1f801db2
+
+
 #define CDR_INT(eCycle) { \
 	psxRegs.interrupt |= (1 << PSXINT_CDR); \
 	psxRegs.intCycle[PSXINT_CDR].cycle = eCycle; \
@@ -124,18 +132,18 @@ extern SPUregisterCallback SPU_registerCallback;
 	psxRegs.intCycle[PSXINT_CDREPPLAY].sCycle = psxRegs.cycle; \
 }
 
-#define CDRDBUF_INT(eCycle) { \

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

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

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

-}

-

-#define CDRLID_INT(eCycle) { \

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

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

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

-}

-

+#define CDRDBUF_INT(eCycle) { \
+	psxRegs.interrupt |= (1 << PSXINT_CDRDBUF); \
+	psxRegs.intCycle[PSXINT_CDRDBUF].cycle = eCycle; \
+	psxRegs.intCycle[PSXINT_CDRDBUF].sCycle = psxRegs.cycle; \
+}
+
+#define CDRLID_INT(eCycle) { \
+	psxRegs.interrupt |= (1 << PSXINT_CDRLID); \
+	psxRegs.intCycle[PSXINT_CDRLID].cycle = eCycle; \
+	psxRegs.intCycle[PSXINT_CDRLID].sCycle = psxRegs.cycle; \
+}
+
 #define StartReading(type, eCycle) { \
    	cdr.Reading = type; \
   	cdr.FirstSector = 1; \
@@ -166,237 +174,237 @@ extern SPUregisterCallback SPU_registerCallback;
 	cdr.ResultC = size; \
 	cdr.ResultReady = 1; \
 }
-

-
-void cdrDecodedBufferInterrupt()

-{

-	u16 buf_ptr[0x400], lcv;

-

-	// ISO reader only

-	if( CDR_init != ISOinit ) return;

-

-

-	// check dbuf IRQ still active

-	if( cdr.Play == 0 ) return;

-	if( (SPU_readRegister( H_SPUctrl ) & 0x40) == 0 ) return;

-	if( (SPU_readRegister( H_SPUirqAddr ) * 8) >= 0x800 ) return;

-

-

-

-	// turn off plugin SPU IRQ decoded buffer handling

-	SPU_registerCallback( 0 );

-

-

-

-	/*

-	Vib Ribbon

-

-	000-3FF = left CDDA

-	400-7FF = right CDDA

-

-	Assume IRQ every wrap

-	*/

-

-	if( iso_play_cdbuf )

-	{

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

-		{

-			// left

-			buf_ptr[ lcv ] = iso_play_cdbuf[ iso_play_bufptr ];

-

-			// right

-			buf_ptr[ lcv+0x200 ] = iso_play_cdbuf[ iso_play_bufptr+1 ];

-

-			iso_play_bufptr += 2;

-		}

-	}

-	else

-	{

-		memset( buf_ptr, 0, sizeof(buf_ptr) );

-	}

-

-

-	// feed CDDA decoded buffer manually

-	SPU_writeRegister( H_SPUaddr,0 );

-	SPU_writeDMAMem( buf_ptr, 0x800 / 2 );

-

-

-	// signal CDDA data ready

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

-

-

-	// time for next full buffer

-	//CDRDBUF_INT( PSXCLK / 44100 * 0x200 );

-	CDRDBUF_INT( PSXCLK / 44100 * 0x100 );

-}

-

-

-void cdrLidSeekInterrupt()

-{

-	// turn back on checking

-	if( cdr.LidCheck == 0x10 )

-	{

-		cdr.LidCheck = 0;

-	}

-

-	// official lid close

-	else if( cdr.LidCheck == 0x30 )

-	{

-		// GS CDX 3.3: $13

-		cdr.StatP |= 0x02;

-		

-

-		// GS CDX 3.3 - ~50 getlocp tries

-		CDRLID_INT( cdReadTime * 3 );

-		cdr.LidCheck = 0x40;

-	}

-

-	// turn off ready

-	else if( cdr.LidCheck == 0x40 )

-	{

-		// GS CDX 3.3: $01

-		cdr.StatP &= ~0x10;

-		cdr.StatP &= ~0x02;

-

-

-		// GS CDX 3.3 - ~50 getlocp tries

-		CDRLID_INT( cdReadTime * 3 );

-		cdr.LidCheck = 0x50;

-	}

-

-	// now seek

-	else if( cdr.LidCheck == 0x50 )

-	{

-		// GameShark Lite: Start seeking ($42)

-		cdr.StatP |= 0x40;

-		cdr.StatP |= 0x02;

-		cdr.StatP &= ~0x01;

-

-

-		CDRLID_INT( cdReadTime * 3 );

-		cdr.LidCheck = 0x60;

-	}

-

-	// done = cd ready

-	else if( cdr.LidCheck == 0x60 )

-	{

-		// GameShark Lite: Seek detection done ($02)

-		cdr.StatP &= ~0x40;

-

-		cdr.LidCheck = 0;

-	}

-}

-

-

-void Check_Shell( int Irq )

-{

-	// check case open/close

-	if (cdr.LidCheck > 0)

-	{

-#ifdef CDR_LOG

-		CDR_LOG( "LidCheck\n" );

-#endif

-

-		// $20 = check lid state

-		if( cdr.LidCheck == 0x20 )

-		{

-			u32 i;

-

-			i = stat.Status;

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

-			{

-				if (stat.Type == 0xff)

-					cdr.Stat = DiskError;

-

-				// case now open

-				else if (stat.Status & 0x10)

-				{

-					// Vib Ribbon: pre-CD swap

-					StopCdda();

-

-

-					// GameShark Lite: Death if DiskError happens

-					//

-					// Vib Ribbon: Needs DiskError for CD swap

-

-					if (Irq != CdlNop)

-					{

-						cdr.Stat = DiskError;

-

-						cdr.StatP |= 0x01;

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

-					}

-

-					// GameShark Lite: Wants -exactly- $10

-					cdr.StatP |= 0x10;

-					cdr.StatP &= ~0x02;

-

-

-					CDRLID_INT( cdReadTime * 3 );

-					cdr.LidCheck = 0x10;

-

-					

-					// GS CDX 3.3 = $11

-				}

-

-				// case just closed

-				else if ( i & 0x10 )

-				{

-					cdr.StatP |= 0x2;

-

-					CheckCdrom();

-

-					

-					if( cdr.Stat == NoIntr )

-						cdr.Stat = Acknowledge;

-

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

-

-

-					// begin close-seek-ready cycle

-					CDRLID_INT( cdReadTime * 3 );

-					cdr.LidCheck = 0x30;

-

-					

-					// GameShark Lite: Wants -exactly- $42, then $02

-					// GS CDX 3.3: Wants $11/$80, $13/$80, $01/$00

-				}

-

-				// case still closed - wait for recheck

-				else

-				{

-					CDRLID_INT( cdReadTime * 3 );

-					cdr.LidCheck = 0x10;

-				}

-			}

-		}

-

-

-		// GS CDX: clear all values but #1,#2

-		if( (cdr.LidCheck >= 0x30) || (cdr.StatP & 0x10) )

-		{

-			SetResultSize(16);

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

-

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

-

-

-			// GS CDX: special return value

-			if( cdr.StatP & 0x10 )

-			{

-				cdr.Result[1] = 0x80;

-			}

-

-

-			if( cdr.Stat == NoIntr )

-				cdr.Stat = Acknowledge;

-

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

-		}

-	}

-}

-

-

+
+
+void cdrDecodedBufferInterrupt()
+{
+	u16 buf_ptr[0x400], lcv;
+
+	// ISO reader only
+	if( CDR_init != ISOinit ) return;
+
+
+	// check dbuf IRQ still active
+	if( cdr.Play == 0 ) return;
+	if( (SPU_readRegister( H_SPUctrl ) & 0x40) == 0 ) return;
+	if( (SPU_readRegister( H_SPUirqAddr ) * 8) >= 0x800 ) return;
+
+
+
+	// turn off plugin SPU IRQ decoded buffer handling
+	SPU_registerCallback( 0 );
+
+
+
+	/*
+	Vib Ribbon
+
+	000-3FF = left CDDA
+	400-7FF = right CDDA
+
+	Assume IRQ every wrap
+	*/
+
+	if( iso_play_cdbuf )
+	{
+		for( lcv = 0; lcv < 0x200; lcv++ )
+		{
+			// left
+			buf_ptr[ lcv ] = iso_play_cdbuf[ iso_play_bufptr ];
+
+			// right
+			buf_ptr[ lcv+0x200 ] = iso_play_cdbuf[ iso_play_bufptr+1 ];
+
+			iso_play_bufptr += 2;
+		}
+	}
+	else
+	{
+		memset( buf_ptr, 0, sizeof(buf_ptr) );
+	}
+
+
+	// feed CDDA decoded buffer manually
+	SPU_writeRegister( H_SPUaddr,0 );
+	SPU_writeDMAMem( buf_ptr, 0x800 / 2 );
+
+
+	// signal CDDA data ready
+	psxHu32ref(0x1070) |= SWAP32((u32)0x200);
+
+
+	// time for next full buffer
+	//CDRDBUF_INT( PSXCLK / 44100 * 0x200 );
+	CDRDBUF_INT( PSXCLK / 44100 * 0x100 );
+}
+
+
+void cdrLidSeekInterrupt()
+{
+	// turn back on checking
+	if( cdr.LidCheck == 0x10 )
+	{
+		cdr.LidCheck = 0;
+	}
+
+	// official lid close
+	else if( cdr.LidCheck == 0x30 )
+	{
+		// GS CDX 3.3: $13
+		cdr.StatP |= 0x02;
+		
+
+		// GS CDX 3.3 - ~50 getlocp tries
+		CDRLID_INT( cdReadTime * 3 );
+		cdr.LidCheck = 0x40;
+	}
+
+	// turn off ready
+	else if( cdr.LidCheck == 0x40 )
+	{
+		// GS CDX 3.3: $01
+		cdr.StatP &= ~0x10;
+		cdr.StatP &= ~0x02;
+
+
+		// GS CDX 3.3 - ~50 getlocp tries
+		CDRLID_INT( cdReadTime * 3 );
+		cdr.LidCheck = 0x50;
+	}
+
+	// now seek
+	else if( cdr.LidCheck == 0x50 )
+	{
+		// GameShark Lite: Start seeking ($42)
+		cdr.StatP |= 0x40;
+		cdr.StatP |= 0x02;
+		cdr.StatP &= ~0x01;
+
+
+		CDRLID_INT( cdReadTime * 3 );
+		cdr.LidCheck = 0x60;
+	}
+
+	// done = cd ready
+	else if( cdr.LidCheck == 0x60 )
+	{
+		// GameShark Lite: Seek detection done ($02)
+		cdr.StatP &= ~0x40;
+
+		cdr.LidCheck = 0;
+	}
+}
+
+
+void Check_Shell( int Irq )
+{
+	// check case open/close
+	if (cdr.LidCheck > 0)
+	{
+#ifdef CDR_LOG
+		CDR_LOG( "LidCheck\n" );
+#endif
+
+		// $20 = check lid state
+		if( cdr.LidCheck == 0x20 )
+		{
+			u32 i;
+
+			i = stat.Status;
+			if (CDR_getStatus(&stat) != -1)
+			{
+				if (stat.Type == 0xff)
+					cdr.Stat = DiskError;
+
+				// case now open
+				else if (stat.Status & 0x10)
+				{
+					// Vib Ribbon: pre-CD swap
+					StopCdda();
+
+
+					// GameShark Lite: Death if DiskError happens
+					//
+					// Vib Ribbon: Needs DiskError for CD swap
+
+					if (Irq != CdlNop)
+					{
+						cdr.Stat = DiskError;
+
+						cdr.StatP |= 0x01;
+						cdr.Result[0] |= 0x01;
+					}
+
+					// GameShark Lite: Wants -exactly- $10
+					cdr.StatP |= 0x10;
+					cdr.StatP &= ~0x02;
+
+
+					CDRLID_INT( cdReadTime * 3 );
+					cdr.LidCheck = 0x10;
+
+					
+					// GS CDX 3.3 = $11
+				}
+
+				// case just closed
+				else if ( i & 0x10 )
+				{
+					cdr.StatP |= 0x2;
+
+					CheckCdrom();
+
+					
+					if( cdr.Stat == NoIntr )
+						cdr.Stat = Acknowledge;
+
+					psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+
+
+					// begin close-seek-ready cycle
+					CDRLID_INT( cdReadTime * 3 );
+					cdr.LidCheck = 0x30;
+
+					
+					// GameShark Lite: Wants -exactly- $42, then $02
+					// GS CDX 3.3: Wants $11/$80, $13/$80, $01/$00
+				}
+
+				// case still closed - wait for recheck
+				else
+				{
+					CDRLID_INT( cdReadTime * 3 );
+					cdr.LidCheck = 0x10;
+				}
+			}
+		}
+
+
+		// GS CDX: clear all values but #1,#2
+		if( (cdr.LidCheck >= 0x30) || (cdr.StatP & 0x10) )
+		{
+			SetResultSize(16);
+			memset( cdr.Result, 0, 16 );
+
+			cdr.Result[0] = cdr.StatP;
+
+
+			// GS CDX: special return value
+			if( cdr.StatP & 0x10 )
+			{
+				cdr.Result[1] = 0x80;
+			}
+
+
+			if( cdr.Stat == NoIntr )
+				cdr.Stat = Acknowledge;
+
+			psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+		}
+	}
+}
+
+
 void Find_CurTrack() {
 	cdr.CurTrack = 0;
 
@@ -414,9 +422,9 @@ void Find_CurTrack() {
 					cdr.CurTrack );
 #endif
 
-				// 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;

+				// 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;
 				if( sect1 >= sect2 ) {
 					cdr.CurTrack++;
 					continue;
@@ -429,9 +437,9 @@ void Find_CurTrack() {
 }
 
 static void ReadTrack( u8 *time ) {
-	cdr.Prev[0] = itob( time[0] );

-	cdr.Prev[1] = itob( time[1] );

-	cdr.Prev[2] = itob( time[2] );

+	cdr.Prev[0] = itob( time[0] );
+	cdr.Prev[1] = itob( time[1] );
+	cdr.Prev[2] = itob( time[2] );
 
 #ifdef CDR_LOG
 	CDR_LOG("ReadTrack() Log: KEY *** %x:%x:%x\n", cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
@@ -439,56 +447,48 @@ static void ReadTrack( u8 *time ) {
 	cdr.RErr = CDR_readTrack(cdr.Prev);
 }
 
-// cdr.Stat:
-#define NoIntr		0
-#define DataReady	1
-#define Complete	2
-#define Acknowledge	3
-#define DataEnd		4
-#define DiskError	5
-
 void AddIrqQueue(unsigned char irq, unsigned long ecycle) {
-	cdr.Irq = irq;

-	cdr.eCycle = ecycle;

-

-	// Doom: Force rescheduling

-	// - Fixes boot

-	CDR_INT(ecycle);

+	cdr.Irq = irq;
+	cdr.eCycle = ecycle;
+
+	// Doom: Force rescheduling
+	// - Fixes boot
+	CDR_INT(ecycle);
 }
 
-

-void Set_Track()

-{

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

-		int lcv;

-

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

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

-#ifdef CDR_LOG___0

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

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

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

-					cdr.CurTrack );

-#endif

-

-				// check if time matches track start (only need min, sec accuracy)

-				// - m:s:f vs f:s:m

-				if( cdr.SetSectorPlay[0] == cdr.ResultTD[2] &&

-						cdr.SetSectorPlay[1] == cdr.ResultTD[1] ) {

-					// skip pregap frames

-					if( cdr.SetSectorPlay[2] < cdr.ResultTD[0] )

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

-

-					break;

-				}

-				else if( cdr.SetSectorPlay[0] < cdr.ResultTD[2] )

-					break;

-			}

-		}

-	}

-}

-

-

+
+void Set_Track()
+{
+	if (CDR_getTN(cdr.ResultTN) != -1) {
+		int lcv;
+
+		for( lcv = 1; lcv < cdr.ResultTN[1]; lcv++ ) {
+			if (CDR_getTD((u8)(lcv), cdr.ResultTD) != -1) {
+#ifdef CDR_LOG___0
+				CDR_LOG( "settrack %d %d %d | %d %d %d | %d\n",
+					cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2],
+					cdr.ResultTD[2], cdr.ResultTD[1], cdr.ResultTD[0],
+					cdr.CurTrack );
+#endif
+
+				// check if time matches track start (only need min, sec accuracy)
+				// - m:s:f vs f:s:m
+				if( cdr.SetSectorPlay[0] == cdr.ResultTD[2] &&
+						cdr.SetSectorPlay[1] == cdr.ResultTD[1] ) {
+					// skip pregap frames
+					if( cdr.SetSectorPlay[2] < cdr.ResultTD[0] )
+						cdr.SetSectorPlay[2] = cdr.ResultTD[0];
+
+					break;
+				}
+				else if( cdr.SetSectorPlay[0] < cdr.ResultTD[2] )
+					break;
+			}
+		}
+	}
+}
+
+
 void cdrRepplayInterrupt()
 {
 	// Wait for IRQ to be acknowledged
@@ -571,7 +571,7 @@ void cdrRepplayInterrupt()
 	// Wild 9: Do not use REPPLAY_ACK
 	CDREPPLAY_INT(cdReadTime);
 
-	Check_Shell( 0 );

+	Check_Shell( 0 );
 
 	psxHu32ref(0x1070) |= SWAP32((u32)0x4);
 }
@@ -580,11 +580,11 @@ void cdrInterrupt() {
 	int i;
 	unsigned char Irq = cdr.Irq;
 
-	// Reschedule IRQ

-	if (cdr.Stat) {

-		CDR_INT( cdr.eCycle );

-		return;

-	}

+	// Reschedule IRQ
+	if (cdr.Stat) {
+		CDR_INT( cdr.eCycle );
+		return;
+	}
 
 	cdr.Irq = 0xff;
 	cdr.Ctrl &= ~0x80;
@@ -601,8 +601,8 @@ void cdrInterrupt() {
 			SetResultSize(1);
 			cdr.Result[0] = cdr.StatP;
 			cdr.Stat = Acknowledge;
-

-			if (cdr.LidCheck == 0) cdr.LidCheck = 0x20;

+
+			if (cdr.LidCheck == 0) cdr.LidCheck = 0x20;
 			break;
 
 		case CdlSetloc:
@@ -613,108 +613,108 @@ void cdrInterrupt() {
 			cdr.Stat = Acknowledge;
 			break;
 
-		case CdlPlay:

-			/*

-			Rayman: detect track changes

-			- fixes logo freeze

-

-			Twisted Metal 2: skip PREGAP + starting accurate SubQ

-			- plays tracks without retry play

-

-			Wild 9: skip PREGAP + starting accurate SubQ

-			- plays tracks without retry play

-			*/

-			Set_Track();

-			Find_CurTrack();

-			ReadTrack( cdr.SetSectorPlay );

-

-

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

-#ifdef CDR_LOG___0

-					CDR_LOG( "PLAY Resume @ %d:%d:%d\n",

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

-#endif

-

-					CDR_play( cdr.SetSectorPlay );

-				}

-				else

-				{

-					// BIOS CD Player: Resume play

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

-#ifdef CDR_LOG___0

-						CDR_LOG( "PLAY Resume T0 @ %d:%d:%d\n",

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

-#endif

-

-						CDR_play( cdr.SetSectorPlay );

-					}

-					else {

-#ifdef CDR_LOG___0

-						CDR_LOG( "PLAY Resume Td @ %d:%d:%d\n",

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

-#endif

-

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

-							}

-						}

-					}

-				}

-			}			

-

-

-			// Vib Ribbon: gameplay checks flag

-			cdr.StatP &= ~0x40;

-

-

-			cdr.CmdProcess = 0;

-			SetResultSize(1);

-			cdr.StatP |= 0x2;

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

-			cdr.Stat = Acknowledge;

-

-			cdr.StatP |= 0x80;

-

-			// Lemmings: report play times

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

-				CDREPPLAY_INT( cdReadTime );

-			}

-			break;

+		case CdlPlay:
+			/*
+			Rayman: detect track changes
+			- fixes logo freeze
+
+			Twisted Metal 2: skip PREGAP + starting accurate SubQ
+			- plays tracks without retry play
+
+			Wild 9: skip PREGAP + starting accurate SubQ
+			- plays tracks without retry play
+			*/
+			Set_Track();
+			Find_CurTrack();
+			ReadTrack( cdr.SetSectorPlay );
+
+
+			// 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 ) {
+#ifdef CDR_LOG___0
+					CDR_LOG( "PLAY Resume @ %d:%d:%d\n",
+						cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
+#endif
+
+					CDR_play( cdr.SetSectorPlay );
+				}
+				else
+				{
+					// BIOS CD Player: Resume play
+					if( cdr.Param[0] == 0 ) {
+#ifdef CDR_LOG___0
+						CDR_LOG( "PLAY Resume T0 @ %d:%d:%d\n",
+							cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
+#endif
+
+						CDR_play( cdr.SetSectorPlay );
+					}
+					else {
+#ifdef CDR_LOG___0
+						CDR_LOG( "PLAY Resume Td @ %d:%d:%d\n",
+							cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
+#endif
+
+						// 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);
+							}
+						}
+					}
+				}
+			}			
+
+
+			// Vib Ribbon: gameplay checks flag
+			cdr.StatP &= ~0x40;
+
+
+			cdr.CmdProcess = 0;
+			SetResultSize(1);
+			cdr.StatP |= 0x2;
+			cdr.Result[0] = cdr.StatP;
+			cdr.Stat = Acknowledge;
+
+			cdr.StatP |= 0x80;
+
+			// Lemmings: report play times
+			if ((cdr.Mode & 0x5) == 0x5) {
+				CDREPPLAY_INT( cdReadTime );
+			}
+			break;
 
     	case CdlForward:
 			cdr.CmdProcess = 0;
@@ -761,16 +761,16 @@ void cdrInterrupt() {
 			cdr.Result[0] = cdr.StatP;
 			cdr.Stat = Complete;
 //			cdr.Stat = Acknowledge;
-

-			if (cdr.LidCheck == 0) cdr.LidCheck = 0x20;

+
+			if (cdr.LidCheck == 0) cdr.LidCheck = 0x20;
 			break;
 
 		case CdlPause:
 			SetResultSize(1);
 			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;

+			cdr.Stat = Acknowledge;
 
-			AddIrqQueue(CdlPause + 0x20, 0x1000);

+			AddIrqQueue(CdlPause + 0x20, 0x1000);
 			cdr.Ctrl |= 0x80;
 			break;
 
@@ -860,10 +860,10 @@ void cdrInterrupt() {
 				memcpy(cdr.Result+5, subq->AbsoluteAddress, 3);
 
 
-				// subQ integrity check - data only (skip audio)

-				if( subq->TrackNumber == 1 && stat.Type == 0x01 ) {

+				// subQ integrity check - data only (skip audio)
+				if( subq->TrackNumber == 1 && stat.Type == 0x01 ) {
 					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

+						memset(cdr.Result + 2, 0, 3 + 3); // CRC wrong, wipe out time data
 					}
 				}
 			} else {
@@ -891,9 +891,9 @@ void cdrInterrupt() {
 			break;
 
     	case CdlGetTN:
-			// 5-Star Racing: don't stop CDDA

-			//

-			// Vib Ribbon: CD swap

+			// 5-Star Racing: don't stop CDDA
+			//
+			// Vib Ribbon: CD swap
 			StopReading();
 
 			cdr.CmdProcess = 0;
@@ -941,7 +941,7 @@ void cdrInterrupt() {
 			cdr.StatP |= 0x2;
 			cdr.StatP &= ~0x40;
         	cdr.Result[0] = cdr.StatP;
-			cdr.Seeked = TRUE;

+			cdr.Seeked = TRUE;
         	cdr.Stat = Complete;
 			break;
 
@@ -960,10 +960,10 @@ void cdrInterrupt() {
 			cdr.StatP &= ~0x40;
 			cdr.Result[0] = cdr.StatP;
 			cdr.Stat = Complete;
-			cdr.Seeked = TRUE;

+			cdr.Seeked = TRUE;
 			
 			// Tomb Raider 2: must update read cursor for getlocp
-			ReadTrack( cdr.SetSectorPlay );

+			ReadTrack( cdr.SetSectorPlay );
 			break;
 
 		case CdlTest:
@@ -1027,21 +1027,21 @@ void cdrInterrupt() {
         	cdr.Stat = Acknowledge;
 			break;
 
-		case CdlReadT:

-			SetResultSize(1);

-			cdr.StatP |= 0x2;

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

-			cdr.Stat = Acknowledge;

-			AddIrqQueue(CdlReadT + 0x20, 0x1000);

-			break;

-

-		case CdlReadT + 0x20:

-			SetResultSize(1);

-			cdr.StatP |= 0x2;

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

-			cdr.Stat = Complete;

-			break;

-

+		case CdlReadT:
+			SetResultSize(1);
+			cdr.StatP |= 0x2;
+			cdr.Result[0] = cdr.StatP;
+			cdr.Stat = Acknowledge;
+			AddIrqQueue(CdlReadT + 0x20, 0x1000);
+			break;
+
+		case CdlReadT + 0x20:
+			SetResultSize(1);
+			cdr.StatP |= 0x2;
+			cdr.Result[0] = cdr.StatP;
+			cdr.Stat = Complete;
+			break;
+
     	case CdlReadToc:
 			SetResultSize(1);
 			cdr.StatP |= 0x2;
@@ -1071,33 +1071,33 @@ void cdrInterrupt() {
 			break;
 
 		case READ_ACK:
-			if (!cdr.Reading) return;

-

-			// Duke Nukem: Land of the Babes - seek then read

-			// - fixes cutscenes

-			if (!cdr.Seeked) {

-				cdr.Seeked = TRUE;

-

-				cdr.StatP |= 0x40;

-				cdr.StatP &= ~0x20;

-			} else {

-				cdr.StatP |= 0x20;

-				cdr.StatP &= ~0x40;

-			}

-

-			/*

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

-			- fixes cutscenes

-

-			Judge Dredd - don't delay too long

-			- breaks gameplay movies

-			*/

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

-

-			SetResultSize(1);

-			cdr.StatP |= 0x02;

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

-			cdr.Stat = Acknowledge;

+			if (!cdr.Reading) return;
+
+			// Duke Nukem: Land of the Babes - seek then read
+			// - fixes cutscenes
+			if (!cdr.Seeked) {
+				cdr.Seeked = TRUE;
+
+				cdr.StatP |= 0x40;
+				cdr.StatP &= ~0x20;
+			} else {
+				cdr.StatP |= 0x20;
+				cdr.StatP &= ~0x40;
+			}
+
+			/*
+			Duke Nukem: Land of the Babes - delay read for one frame
+			- fixes cutscenes
+
+			Judge Dredd - don't delay too long
+			- breaks gameplay movies
+			*/
+			CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
+
+			SetResultSize(1);
+			cdr.StatP |= 0x02;
+			cdr.Result[0] = cdr.StatP;
+			cdr.Stat = Acknowledge;
 			break;
 
 		case 0xff:
@@ -1108,8 +1108,8 @@ void cdrInterrupt() {
 			break;
 	}
 
-	Check_Shell( Irq );

-

+	Check_Shell( Irq );
+
 	if (cdr.Stat != NoIntr && cdr.Reg2 != 0x18) {
 		psxHu32ref(0x1070) |= SWAP32((u32)0x4);
 	}
@@ -1140,7 +1140,7 @@ void cdrReadInterrupt() {
 	cdr.StatP &= ~0x40;
     cdr.Result[0] = cdr.StatP;
 
-	ReadTrack( cdr.SetSector );

+	ReadTrack( cdr.SetSector );
 
 	buf = CDR_getBuffer();
 	if (buf == NULL)
@@ -1219,28 +1219,28 @@ void cdrReadInterrupt() {
 	Hokuto no Ken 2: $A0 - return FORM1 + FORM2
 	Judge Dredd: $C8 - only FORM1
 	Xenogears: $C8 - only FORM1
-	*/

-

-	// To fix Judge Dredd movies: use first block

-#if 0

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

-    cdr.Stat = DataReady;

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

-  }

-#elif 0

+	*/
+
+	// To fix Judge Dredd movies: use first block
+#if 0
+	if( (cdr.Mode & 0x40) == 0 || (cdr.Transfer[4+2] & 0x4) != 0x4 ) {
+    cdr.Stat = DataReady;
+    psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+  }
+#elif 0
 	if( (cdr.Mode & 0x40) == 0 || (cdr.Transfer[4+2] & 0x4) != 0x4 ) {
-    cdr.Stat = DataReady;

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

+    cdr.Stat = DataReady;
+    psxHu32ref(0x1070) |= SWAP32((u32)0x4);
   } else {
     cdr.Stat = Acknowledge;
-    psxHu32ref(0x1070) |= SWAP32((u32)0x4);

-  }

+    psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+  }
 #else
-    cdr.Stat = DataReady;

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

+    cdr.Stat = DataReady;
+    psxHu32ref(0x1070) |= SWAP32((u32)0x4);
 #endif
-

-	Check_Shell(0);

+
+	Check_Shell(0);
 }
 
 /*
@@ -1287,19 +1287,19 @@ void cdrWrite0(unsigned char rt) {
 #endif
 	cdr.Ctrl = rt | (cdr.Ctrl & ~0x3);
 
-	if (rt == 0) {

-		cdr.ParamP = 0;

-		cdr.ParamC = 0;

-		cdr.ResultReady = 0;

-	}

-

-	// Tekken: CDXA fade-out

-	else if( rt == 2 ) {

-		cdr.LeftVol = 0;

-	}

-	else if( rt == 3 ) {

-		cdr.RightVol = 0;

-	}

+	if (rt == 0) {
+		cdr.ParamP = 0;
+		cdr.ParamC = 0;
+		cdr.ResultReady = 0;
+	}
+
+	// Tekken: CDXA fade-out
+	else if( rt == 2 ) {
+		cdr.LeftVol = 0;
+	}
+	else if( rt == 3 ) {
+		cdr.RightVol = 0;
+	}
 }
 
 unsigned char cdrRead1(void) {
@@ -1324,14 +1324,14 @@ void cdrWrite1(unsigned char rt) {
 #ifdef CDR_LOG
 	CDR_LOG("cdrWrite1() Log: CD1 write: %x (%s)\n", rt, CmdName[rt]);
 #endif
-

-	

-	// Tekken: CDXA fade-out

-	if( (cdr.Ctrl & 3) == 3 ) {

-		cdr.RightVol |= (rt << 8);

-	}

-

-  

+
+	
+	// Tekken: CDXA fade-out
+	if( (cdr.Ctrl & 3) == 3 ) {
+		cdr.RightVol |= (rt << 8);
+	}
+
+  
 	//	psxHu8(0x1801) = rt;
   cdr.Cmd = rt;
 	cdr.OCUP = 0;
@@ -1401,24 +1401,24 @@ void cdrWrite1(unsigned char rt) {
     		AddIrqQueue(cdr.Cmd, 0x1000);
         break;
 
-			case CdlPlay:

-				// Vib Ribbon: try same track again

-				StopCdda();

-

-				// Vib Ribbon - decoded buffer IRQ for CDDA reading

-				// - fixes ribbon timing + music CD mode

-				CDRDBUF_INT( PSXCLK / 44100 * 0x100 );

-

-				

-				cdr.Play = TRUE;

-

-				cdr.StatP |= 0x40;

-				cdr.StatP &= ~0x02;

-

-				cdr.Ctrl |= 0x80;

-				cdr.Stat = NoIntr; 

-				AddIrqQueue(cdr.Cmd, 0x1000);

-				break;

+			case CdlPlay:
+				// Vib Ribbon: try same track again
+				StopCdda();
+
+				// Vib Ribbon - decoded buffer IRQ for CDDA reading
+				// - fixes ribbon timing + music CD mode
+				CDRDBUF_INT( PSXCLK / 44100 * 0x100 );
+
+				
+				cdr.Play = TRUE;
+
+				cdr.StatP |= 0x40;
+				cdr.StatP &= ~0x02;
+
+				cdr.Ctrl |= 0x80;
+				cdr.Stat = NoIntr; 
+				AddIrqQueue(cdr.Cmd, 0x1000);
+				break;
 
     	case CdlForward:
         //if (cdr.CurTrack < 0xaa)
@@ -1495,18 +1495,18 @@ void cdrWrite1(unsigned char rt) {
 				StopReading();
 				cdr.Ctrl |= 0x80;
     		cdr.Stat = NoIntr;
-

-				/*

-				Gundam Battle Assault 2: much slower (*)

-				- Fixes boot, gameplay

-				

-				Hokuto no Ken 2: slower

-				- Fixes intro + subtitles

-

-				InuYasha - Feudal Fairy Tale: slower

-				- Fixes battles

-				*/

-				AddIrqQueue(cdr.Cmd, cdReadTime * 3);

+
+				/*
+				Gundam Battle Assault 2: much slower (*)
+				- Fixes boot, gameplay
+				
+				Hokuto no Ken 2: slower
+				- Fixes intro + subtitles
+
+				InuYasha - Feudal Fairy Tale: slower
+				- Fixes battles
+				*/
+				AddIrqQueue(cdr.Cmd, cdReadTime * 3);
         break;
 
 		case CdlReset:
@@ -1523,10 +1523,10 @@ void cdrWrite1(unsigned char rt) {
 			cdr.Ctrl |= 0x80;
     		cdr.Stat = NoIntr; 
     		AddIrqQueue(cdr.Cmd, 0x1000);
-

-			// cd-xa volume

-			SPU_writeRegister( H_CDLeft, 0x0000 );

-			SPU_writeRegister( H_CDRight, 0x0000 );

+
+			// cd-xa volume
+			SPU_writeRegister( H_CDLeft, 0x0000 );
+			SPU_writeRegister( H_CDRight, 0x0000 );
         	break;
 
     	case CdlDemute:
@@ -1534,11 +1534,11 @@ void cdrWrite1(unsigned char rt) {
 			cdr.Ctrl |= 0x80;
     		cdr.Stat = NoIntr; 
     		AddIrqQueue(cdr.Cmd, 0x1000);
-

-			// Vib Ribbon: get music to output volume

-			// cd-xa volume

-			SPU_writeRegister( H_CDLeft, 0x7f00 );

-			SPU_writeRegister( H_CDRight, 0x7f00 );

+
+			// Vib Ribbon: get music to output volume
+			// cd-xa volume
+			SPU_writeRegister( H_CDLeft, 0x7f00 );
+			SPU_writeRegister( H_CDRight, 0x7f00 );
         	break;
 
     	case CdlSetfilter:
@@ -1557,11 +1557,11 @@ void cdrWrite1(unsigned char rt) {
 			cdr.Ctrl |= 0x80;
     		cdr.Stat = NoIntr; 
     		AddIrqQueue(cdr.Cmd, 0x1000);
-

-			// Squaresoft on PlayStation 1998 Collector's CD Vol. 1

-			// - fixes choppy movie sound

-			if( cdr.Play && (cdr.Mode & 1) == 0 )

-				StopCdda();

+
+			// Squaresoft on PlayStation 1998 Collector's CD Vol. 1
+			// - fixes choppy movie sound
+			if( cdr.Play && (cdr.Mode & 1) == 0 )
+				StopCdda();
         	break;
 
     	case CdlGetmode:
@@ -1617,13 +1617,13 @@ void cdrWrite1(unsigned char rt) {
     		AddIrqQueue(cdr.Cmd, 0x1000);
         	break;
 
-		// Destruction Derby: read TOC? GetTD after this

-		case CdlReadT:

-			cdr.Ctrl |= 0x80;

-			cdr.Stat = NoIntr; 

-			AddIrqQueue(cdr.Cmd, 0x1000);

-			break;

-

+		// Destruction Derby: read TOC? GetTD after this
+		case CdlReadT:
+			cdr.Ctrl |= 0x80;
+			cdr.Stat = NoIntr; 
+			AddIrqQueue(cdr.Cmd, 0x1000);
+			break;
+
     	case CdlTest:
 			cdr.Ctrl |= 0x80;
     		cdr.Stat = NoIntr; 
@@ -1680,18 +1680,18 @@ void cdrWrite2(unsigned char rt) {
 #ifdef CDR_LOG
 	CDR_LOG("cdrWrite2() Log: CD2 write: %x\n", rt);
 #endif
-

-	

-	// Tekken: CDXA fade-out

-	if( (cdr.Ctrl & 3) == 2 ) {

-		cdr.LeftVol |= (rt << 8);

-	}

-	else if( (cdr.Ctrl & 3) == 3 ) {

-		cdr.RightVol |= (rt << 0);

-	}

-

-  

-	

+
+	
+	// Tekken: CDXA fade-out
+	if( (cdr.Ctrl & 3) == 2 ) {
+		cdr.LeftVol |= (rt << 8);
+	}
+	else if( (cdr.Ctrl & 3) == 3 ) {
+		cdr.RightVol |= (rt << 0);
+	}
+
+  
+	
     if (cdr.Ctrl & 0x1) {
 		switch (rt) {
 			case 0x07:
@@ -1731,28 +1731,28 @@ void cdrWrite3(unsigned char rt) {
 	CDR_LOG("cdrWrite3() Log: CD3 write: %x\n", rt);
 #endif
 
-	// Tekken: CDXA fade-out

-	if( (cdr.Ctrl & 3) == 2 ) {

-		cdr.LeftVol |= (rt << 0);

-	}

-	else if( (cdr.Ctrl & 3) == 3 && rt == 0x20 ) {

-#ifdef CDR_LOG

-		CDR_LOG( "CD-XA Volume: %X %X\n", cdr.LeftVol, cdr.RightVol );

-#endif

-

-		if( !cdr.Muted ) {

-			/*

-			Eternal SPU: scale volume from [0-ffff] -> [0,8000]

-			- Destruction Derby Raw movies (ff00)

-			*/

-

-			// write CD-XA volumes

-			SPU_writeRegister( H_CDLeft, cdr.LeftVol / 2 );

-			SPU_writeRegister( H_CDRight, cdr.RightVol / 2 );

-		}

-	}

-

-	

+	// Tekken: CDXA fade-out
+	if( (cdr.Ctrl & 3) == 2 ) {
+		cdr.LeftVol |= (rt << 0);
+	}
+	else if( (cdr.Ctrl & 3) == 3 && rt == 0x20 ) {
+#ifdef CDR_LOG
+		CDR_LOG( "CD-XA Volume: %X %X\n", cdr.LeftVol, cdr.RightVol );
+#endif
+
+		if( !cdr.Muted ) {
+			/*
+			Eternal SPU: scale volume from [0-ffff] -> [0,8000]
+			- Destruction Derby Raw movies (ff00)
+			*/
+
+			// write CD-XA volumes
+			SPU_writeRegister( H_CDLeft, cdr.LeftVol / 2 );
+			SPU_writeRegister( H_CDRight, cdr.RightVol / 2 );
+		}
+	}
+
+	
 	// GameShark CDX CD Player: Irq timing mania
 	if( rt == 0 &&
 			cdr.Irq != 0 && cdr.Irq != 0xff &&
@@ -1775,11 +1775,11 @@ void cdrWrite3(unsigned char rt) {
 			return;
 		}
 
-		/*

-		Do not reset interrupts here

-		- Doom: fixes boot

-		- Judge Dredd: better gameplay, some dropped frames

-		*/

+		/*
+		Do not reset interrupts here
+		- Doom: fixes boot
+		- Judge Dredd: better gameplay, some dropped frames
+		*/
 
 		return;
 	}
@@ -1793,11 +1793,11 @@ void cdrWrite3(unsigned char rt) {
 			case 0x00:
 				cdr.pTransfer += 12;
 				break;
-

-			case 0x20:

-				cdr.pTransfer += 0;

-				break;

-

+
+			case 0x20:
+				cdr.pTransfer += 0;
+				break;
+
 			default:
 				break;
 		}
@@ -1852,14 +1852,14 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 			psxCpu->Clear(madr, cdsize / 4);
 			cdr.pTransfer += cdsize;
 
-

-			// burst vs normal

-			if( chcr == 0x11400100 ) {

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

-			}

-			else if( chcr == 0x11000000 ) {

-				CDRDMA_INT( (cdsize/4) * 1 );

-			}

+
+			// burst vs normal
+			if( chcr == 0x11400100 ) {
+				CDRDMA_INT( (cdsize/4) / 4 );
+			}
+			else if( chcr == 0x11000000 ) {
+				CDRDMA_INT( (cdsize/4) * 1 );
+			}
 			return;
 
 		default:
@@ -1903,7 +1903,7 @@ int cdrFreeze(gzFile f, int Mode) {
 }
 
 void LidInterrupt() {
-	cdr.LidCheck = 0x20; // start checker

+	cdr.LidCheck = 0x20; // start checker
 
 	// generate interrupt if none active - open or close
 	if (cdr.Irq == 0 || cdr.Irq == 0xff) {