X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fjaguar.cpp;h=df4c139afc4ab061396301cacdd93a2bf2aa118e;hb=c1aa2a5180362f141ce43b76942952e1f6680347;hp=268befde8a1066121820e6219c06a47cbf6bbde1;hpb=e285d9bb9ae73f64443fa4add30119dc422c4d08;p=virtualjaguar

diff --git a/src/jaguar.cpp b/src/jaguar.cpp
index 268befd..df4c139 100644
--- a/src/jaguar.cpp
+++ b/src/jaguar.cpp
@@ -88,6 +88,37 @@ static bool start = false;
 void M68KInstructionHook(void)
 {
 	uint32 m68kPC = m68k_get_reg(NULL, M68K_REG_PC);
+// Temp, for comparing...
+{
+/*	static char buffer[2048];//, mem[64];
+	m68k_disassemble(buffer, m68kPC, M68K_CPU_TYPE_68000);
+	printf("%08X: %s\n", m68kPC, buffer);//*/
+}
+//JaguarDasm(m68kPC, 1);
+//Testing Hover Strike...
+#if 0
+//Dasm(regs.pc, 1);
+static int hitCount = 0;
+static int inRoutine = 0;
+static int instSeen;
+
+//if (regs.pc == 0x80340A)
+if (m68kPC == 0x803416)
+{
+	hitCount++;
+	inRoutine = 1;
+	instSeen = 0;
+	printf("%i: $80340A start. A0=%08X, A1=%08X ", hitCount, m68k_get_reg(NULL, M68K_REG_A0), m68k_get_reg(NULL, M68K_REG_A1));
+}
+else if (m68kPC == 0x803422)
+{
+	inRoutine = 0;
+	printf("(%i instructions)\n", instSeen);
+}
+
+if (inRoutine)
+	instSeen++;
+#endif
 
 // For tracebacks...
 // Ideally, we'd save all the registers as well...
@@ -854,7 +885,7 @@ int irq_ack_handler(int level)
 	// Tracing the IPL lines on the Jaguar schematic yields the following:
 	// IPL1 is connected to INTL on TOM (OUT to 68K)
 	// IPL0-2 are also tied to Vcc via 4.7K resistors!
-	// (DINT on TOM goes into DINT on JERRY (IN from Jerry))
+	// (DINT on TOM goes into DINT on JERRY (IN Tom from Jerry))
 	// There doesn't seem to be any other path to IPL0 or 2 on the schematic, which means
 	// that *all* IRQs to the 68K are routed thru TOM at level 2. Which means they're all maskable.
 
@@ -1054,6 +1085,9 @@ void m68k_write_memory_8(unsigned int address, unsigned int value)
 /*if (effect_start)
 	if (address >= 0x18FA70 && address < (0x18FA70 + 8000))
 		WriteLog("M68K: Byte %02X written at %08X by 68K\n", value, address);//*/
+//$53D0
+/*if (address >= 0x53D0 && address <= 0x53FF)
+	printf("M68K: Writing byte $%02X at $%08X, PC=$%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
 
 #ifndef USE_NEW_MMU
 	if ((address >= 0x000000) && (address <= 0x3FFFFF))
@@ -1117,6 +1151,9 @@ if (address == 0xF02110)
 /*	if (address == 0x51136 || address == 0x51138 || address == 0xFB074 || address == 0xFB076
 		|| address == 0x1AF05E)
 		WriteLog("[WM16  PC=%08X] Addr: %08X, val: %04X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);//*/
+//$53D0
+/*if (address >= 0x53D0 && address <= 0x53FF)
+	printf("M68K: Writing word $%04X at $%08X, PC=$%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
 
 #ifndef USE_NEW_MMU
 	if ((address >= 0x000000) && (address <= 0x3FFFFE))
@@ -1623,7 +1660,7 @@ void JaguarInit(void)
 }
 
 //New timer based code stuffola...
-void ScanlineCallback(void);
+void HalflineCallback(void);
 void RenderCallback(void);
 void JaguarReset(void)
 {
@@ -1649,9 +1686,8 @@ void JaguarReset(void)
 	// New timer base code stuffola...
 	InitializeEventList();
 //	SetCallbackTime(ScanlineCallback, 63.5555);
-	SetCallbackTime(ScanlineCallback, 31.77775);
-//	SetCallbackTime(RenderCallback, 33303.082);	// # Scanlines * scanline time
-//	SetCallbackTime(RenderCallback, 16651.541);	// # Scanlines * scanline time
+//	SetCallbackTime(ScanlineCallback, 31.77775);
+	SetCallbackTime(HalflineCallback, (vjs.hardwareTypeNTSC ? 31.777777777 : 32.0));
 }
 
 void JaguarDone(void)
@@ -1777,8 +1813,8 @@ void JaguarDone(void)
 	JaguarDasm(0x802000, 6000);
 	WriteLog("\n");//*/
 #endif
-/*	WriteLog("\n\nM68000 disassembly at $080000...\n");
-	JaguarDasm(0x080000, 10000);
+/*	WriteLog("\n\nM68000 disassembly at $4000...\n");
+	JaguarDasm(0x4000, 10000);
 	WriteLog("\n");//*/
 }
 
@@ -1806,6 +1842,8 @@ void JaguarExecute(uint32 * backbuffer, bool render)
 //seem to indicate the refresh rate is *half* the above...
 //	uint16 refreshRate = (vjs.hardwareTypeNTSC ? 30 : 25);
 	// Should these be hardwired or read from VP? Yes, from VP!
+	// Err, actually, they should be hardwired, and hardwired to a set # of
+	// lines as well...
 	uint32 M68KCyclesPerScanline = m68kClockRate / (vp * refreshRate);
 	uint32 RISCCyclesPerScanline = m68kClockRate / (vp * refreshRate);
 
@@ -1860,7 +1898,7 @@ if (effect_start)
 
 //if (start_logging)
 //	WriteLog("About to execute OP (%u)...\n", i);
-		TOMExecScanline(i, render);
+		TOMExecHalfline(i, render);
 	}
 }
 
@@ -1914,15 +1952,46 @@ void JaguarExecuteNew(void)
 	while (!frameDone);
 }
 
-void ScanlineCallback(void)
+#define USE_CORRECT_PAL_TIMINGS
+// A lot of confusion comes from here...
+// The thing to keep in mind is that the VC is advanced every HALF line, regardless
+// of whether the display is interlaced or not. The only difference with an
+// interlaced display is that the high bit of VC will be set when the lower
+// field is being rendered.
+//
+// Normally, TVs will render a full frame in 1/30s (NTSC) or 1/25s (PAL) by
+// rendering two fields that are slighty vertically offset from each other.
+// Each field is created in 1/60s (NTSC) or 1/50s (PAL), and every other line
+// is rendered in this mode so that each field, when overlaid on each other,
+// will yield the final picture at the full resolution for the full frame.
+//
+// We execute a half frame in each timeslice (1/60s NTSC, 1/50s PAL).
+// Since the number of lines in a FULL frame is 525 for NTSC, 625 for PAL,
+// it will be half this number for a half frame. BUT, since we're counting
+// HALF lines, we double this number and we're back at 525 for NTSC, 625 for PAL.
+//
+// Scanline times are 63.5555... µs in NTSC and 64 µs in PAL
+// Half line times are, naturally, half of this. :-P
+void HalflineCallback(void)
 {
+//OK, this is hardwired to run in NTSC, and for who knows how long.
+//Need to fix this so that it does a half-line in the correct amount of time
+//and number of lines, depending on which mode we're in. [FIXED]
 	uint16 vc = TOMReadWord(0xF00006, JAGUAR);
 	uint16 vp = TOMReadWord(0xF0003E, JAGUAR) + 1;
 	uint16 vi = TOMReadWord(0xF0004E, JAGUAR);
 //	uint16 vbb = TOMReadWord(0xF00040, JAGUAR);
 	vc++;
 
+#ifdef USE_CORRECT_PAL_TIMINGS
+	// Each # of lines is for a full frame == 1/30s (NTSC), 1/25s (PAL).
+	// So we cut the number of half-lines in a frame in half. :-P
+	uint16 numHalfLines = ((vjs.hardwareTypeNTSC ? 525 : 625) * 2) / 2;
+
+	if (vc >= numHalfLines)
+#else
 	if (vc >= vp)
+#endif
 		vc = 0;
 
 //WriteLog("SLC: Currently on line %u (VP=%u)...\n", vc, vp);
@@ -1938,7 +2007,7 @@ void ScanlineCallback(void)
 		m68k_set_irq(2);
 	}
 
-	TOMExecScanline(vc, true);
+	TOMExecHalfline(vc, true);
 
 //Change this to VBB???
 //Doesn't seem to matter (at least for Flip Out & I-War)
@@ -1949,8 +2018,12 @@ void ScanlineCallback(void)
 		frameDone = true;
 	}//*/
 
-//	SetCallbackTime(ScanlineCallback, 63.5555);
-	SetCallbackTime(ScanlineCallback, 31.77775);
+#ifdef USE_CORRECT_PAL_TIMINGS
+	SetCallbackTime(HalflineCallback, (vjs.hardwareTypeNTSC ? 31.777777777 : 32.0));
+#else
+//	SetCallbackTime(HalflineCallback, 63.5555);
+	SetCallbackTime(HalflineCallback, 31.77775);
+#endif
 }
 
 // This isn't currently used, but maybe it should be...