Adjust GAMESTART logic, consolidate VIP sign-extensions

core/bus.c

@@ -159,6 +159,8 @@ static void busRead(VB *sim, uint32_t address, int type, int32_t *value) {
 
         case 2: /* Misc. I/O */
             *value = busReadMisc(sim, address, type);
+            if (type == VB_S8)
+                *value = (int8_t) *value;
             break;
 
         case 3: break; /* Unmapped */

core/cpu.c

@@ -1637,6 +1637,7 @@ static void cpuSUBF_S(VB *sim) {
 /* TRAP */
 static void cpuTRAP(VB *sim) {
     sim->cpu.clocks += cpuClocks(15);
+    sim->cpu.pc     += 2;
     cpuThrow(sim, 0xFFA0 + cpuGetImm5U(sim));
 }
 

core/timer.c

@@ -5,6 +5,15 @@
 
 /***************************** Module Functions ******************************/
 
+/* Compute clocks until the next decrement to zero */
+static uint32_t tmrGetUntil(VB *sim) {
+    uint32_t fullTick = sim->tmr.t_clk_sel ? 400 : 2000;
+    uint32_t thisTick = sim->tmr.clocks +
+        (sim->tmr.t_clk_sel ? 0 : 400 * (4 - sim->tmr.tick20));
+    return thisTick + fullTick *
+        (sim->tmr.counter == 0 ? sim->tmr.reload : sim->tmr.counter - 1);
+}
+
 /* Update the counter to a new value */
 static void tmrUpdate(VB *sim, uint16_t value) {
     if (value == 0 && sim->tmr.counter != 0) {
@@ -23,10 +32,6 @@ static void tmrUpdate(VB *sim, uint16_t value) {
 /* Process component */
 static void tmrEmulate(VB *sim, uint32_t clocks) {
 
-    /* Timer is disabled */
-    if (!sim->tmr.t_enb)
-        return;
-
     /* Process all clocks */
     for (;;) {
 
@@ -38,15 +43,22 @@ static void tmrEmulate(VB *sim, uint32_t clocks) {
         }
 
         /* Advance forward the component's number of clocks */
-        clocks         -= sim->tmr.clocks;
+        clocks          -= sim->tmr.clocks;
-        sim->tmr.until -= sim->tmr.clocks;
+        sim->tmr.until  -= sim->tmr.clocks;
-        sim->tmr.clocks = sim->tmr.t_clk_sel ? 400 : 2000;
+        sim->tmr.clocks  = 400;
+        sim->tmr.tick20 += sim->tmr.tick20 == 4 ? -4 : 1;
+
+        /* Do not decrement counter */
+        if (
+            !sim->tmr.t_enb ||
+            (!sim->tmr.t_clk_sel && sim->tmr.tick20 != 0)
+        ) continue;
 
         /* Advance to the next counter value */
         tmrUpdate(sim, sim->tmr.counter == 0 ?
             sim->tmr.reload : sim->tmr.counter - 1);
         if (sim->tmr.counter == 0)
-            sim->tmr.until = sim->tmr.clocks * ((uint32_t)sim->tmr.reload + 1);
+            sim->tmr.until = tmrGetUntil(sim);
     }
 
 }
@@ -71,8 +83,10 @@ static void tmrReset(VB *sim) {
     sim->tmr.z_stat    = 0;
 
     /* Other */
+    sim->tmr.clocks  = 400;
     sim->tmr.counter = 0xFFFF;
     sim->tmr.reload  = 0x0000;
+    sim->tmr.tick20  = 0;
 }
 
 /* Determine how many clocks are guaranteed to process */
@@ -88,14 +102,27 @@ static void tmrWriteControl(VB *sim, uint8_t value) {
     if (
         (value & 0x04) && /* Z-Stat-Clr */
         (
-            sim->tmr.counter != 0 ||
+            !sim->tmr.t_enb ||
-            !sim->tmr.t_enb
+            (
+                sim->tmr.counter != 0 &&
+                !(value & 0x01) /* T-Enb */
+            )
         )
     ) {
         sim->tmr.z_stat = sim->tmr.counter != 0;
         sim->cpu.irq   &= ~0x0002;
     }
 
+    /* Hardware bug: decrement on switch to 20us mode */
+    if (
+        !sim->tmr.t_clk_sel &&
+        (value & 0x10)      && /* T-Clk-Sel */
+        sim->tmr.tick20 != 0
+    ) {
+        tmrUpdate(sim, sim->tmr.counter == 0 ?
+            sim->tmr.reload : sim->tmr.counter - 1);
+    }
+
     /* Parse fields */
     sim->tmr.t_clk_sel = value >> 4 & 1;
     sim->tmr.tim_z_int = value >> 3 & 1;
@@ -105,10 +132,8 @@ static void tmrWriteControl(VB *sim, uint8_t value) {
     if (!sim->tmr.tim_z_int)
         sim->cpu.irq &= ~0x0002;
 
-    /* Configure countdowns */
+    /* Configure state */
-    sim->tmr.clocks = sim->tmr.t_clk_sel ? 400 : 2000;
+    sim->tmr.until = tmrGetUntil(sim);
-    sim->tmr.until  = sim->tmr.clocks * (sim->tmr.counter == 0 ?
-        (uint32_t) sim->tmr.reload + 1 : sim->tmr.counter);
 
     /* TODO: Will Z-Stat raise an interrupt when Tim-Z-Int is set? */
 }
@@ -117,12 +142,14 @@ static void tmrWriteControl(VB *sim, uint8_t value) {
 static void tmrWriteHigh(VB *sim, uint8_t value) {
     sim->tmr.reload = (uint16_t) value << 8 | (sim->tmr.reload & 0x00FF);
     tmrUpdate(sim, sim->tmr.reload);
+    sim->tmr.until  = tmrGetUntil(sim);
 }
 
 /* Write to the low data register */
 static void tmrWriteLow(VB *sim, uint8_t value) {
     sim->tmr.reload = (sim->tmr.reload & 0xFF00) | value;
     tmrUpdate(sim, sim->tmr.reload);
+    sim->tmr.until  = tmrGetUntil(sim);
 }
 
 

core/vb.c

@@ -251,6 +251,7 @@ struct VB {
         uint32_t clocks;  /* Master clocks to wait */
         uint16_t counter; /* Current counter value */
         uint16_t reload;  /* Reload counter value */
+        uint8_t  tick20;  /* Current 20-microsecond tick */
         uint32_t until;   /* Clocks until interrupt condition */
     } tmr;
 
@@ -311,6 +312,7 @@ struct VB {
             int      frame;    /* FRMCYC counter */
             int32_t  halfword; /* Current output halfword offset */
             int      step;     /* Processing phase */
+            uint8_t  toggle;   /* Switch frame buffers next frame */
             uint32_t until;    /* Clocks until interrupt condition */
         } xp;
 
@@ -325,6 +327,7 @@ struct VB {
         uint16_t spt[4];     /* Object control */
 
         /* Rendering shadow memory */
+        uint8_t  buffer;            /* Output buffer */
         uint16_t halfwords[384*28]; /* Output timing by 1x8 halfword */
         Pixels   output[2];         /* Output images, row-major */
         Pixels   shadow;            /* Drawing shadow image, column-major */
@@ -631,7 +634,7 @@ VBAPI void vbGetPixels(VB *sim, void *left, int leftStrideX, int leftStrideY,
             continue;
 
         /* Transfer pixels to the destination */
-        src = sim->vip.output[sim->vip.dp.buffer ^ 1][i];
+        src = sim->vip.output[sim->vip.buffer][i];
         for (y = 0; y < 224; y++, dest += yStride)
         for (x = offset = 0; x < 384; x++, offset += xStride)
             dest[offset] = *src++;

core/vb.h

@@ -126,7 +126,6 @@ typedef int  (*vbOnWrite    )(VB *sim, uint32_t address, int type, int32_t *valu
 
 VBAPI int           vbEmulate             (VB *sim, uint32_t *clocks);
 VBAPI int           vbEmulateEx           (VB **sims, unsigned count, uint32_t *clocks);
-VBAPI void*         vbGetCallback         (VB *sim, int id);
 VBAPI void*         vbGetCartRAM          (VB *sim, uint32_t *size);
 VBAPI void*         vbGetCartROM          (VB *sim, uint32_t *size);
 VBAPI vbOnException vbGetExceptionCallback(VB *sim);

core/vip.c

@@ -234,7 +234,7 @@ static void vipWriteCell(VB *sim, uint32_t offset, int type, int32_t value) {
         case VB_S8:
         case VB_U8:
             value = offset & 1 ?
-                value << 8 |           sim->vip.ram[0x20000 | offset] :
+                value << 8 |           sim->vip.ram[0x20001 ^ offset] :
                 value      | (int32_t) sim->vip.ram[0x20001 | offset] << 8
             ;
             break;
@@ -284,7 +284,7 @@ static void vipWriteObject(VB *sim, uint32_t offset, int type, int32_t value) {
         case VB_S8:
         case VB_U8:
             value = offset & 1 ?
-                value << 8 |           sim->vip.ram[0x3E000 | offset] :
+                value << 8 |           sim->vip.ram[0x3E001 ^ offset] :
                 value      | (int32_t) sim->vip.ram[0x3E001 | offset] << 8
             ;
             break;
@@ -326,7 +326,7 @@ static void vipWriteWorld(VB *sim, uint32_t offset, int type, int32_t value) {
         case VB_S8:
         case VB_U8:
             value = offset & 1 ?
-                value << 8 |           sim->vip.ram[0x3D800 | offset] :
+                value << 8 |           sim->vip.ram[0x3D801 ^ offset] :
                 value      | (int32_t) sim->vip.ram[0x3D801 | offset] << 8
             ;
             break;
@@ -481,10 +481,12 @@ static void vipWriteIO(
             break;
 
         case 0x5F830>>1: /* CTA */
-            if ((mask & 0xFF00) == 0)
+            if (debug) {
-                sim->vip.cta.cta_r = value >> 8;
+                if ((mask & 0xFF00) == 0)
-            if ((mask & 0x00FF) == 0)
+                    sim->vip.cta.cta_r = value >> 8;
-                sim->vip.cta.cta_l = value;
+                if ((mask & 0x00FF) == 0)
+                    sim->vip.cta.cta_l = value;
+            }
             break;
 
         case 0x5F842>>1: /* XPCTRL */
@@ -596,7 +598,7 @@ static void vipTransferColumn(VB *sim, int32_t eye) {
 
     /* Select destination address in host memory */
     dest = &sim->vip.output
-        [sim->vip.dp.buffer][eye][sim->vip.dp.column];
+        [sim->vip.buffer ^ 1][eye][sim->vip.dp.column];
 
     /* Output is disabled */
     if (!sim->vip.dp.enabled) {
@@ -652,28 +654,29 @@ static int vipEmulateDisplay(VB *sim, uint32_t clocks) {
                 vipThrow(sim, 0x0010); /* FRAMESTART */
 
                 /* Game frame */
-                if (sim->vip.xp.xpen) {
+                if (sim->vip.xp.frame >= sim->vip.frmcyc) {
-                    if (sim->vip.xp.frame >= sim->vip.frmcyc) {
+                    sim->vip.xp.frame = 0;
-                        sim->vip.xp.frame = 0;
 
-                        /* Initiate drawing procedure */
+                    vipThrow(sim, 0x0008); /* GAMESTART */
-                        if (sim->vip.xp.step == 0) {
+                    if (sim->vip.xp.step != 0) {
-                            sim->vip.dp.buffer  ^= 1;
+                        sim->vip.xp.overtime = 1;
-                            sim->vip.xp.enabled  = 1;
+                        vipThrow(sim, 0x8000); /* TIMEERR */
-                            sim->vip.xp.overtime = 0;
+                    }
-                            sim->vip.xp.step     = 1;
-                            vipThrow(sim, 0x0008); /* GAMESTART */
-                        }
 
-                        /* Drawing procedure has run into overtime */
+                    /* Initiate drawing procedure */
-                        else {
+                    else if (sim->vip.xp.xpen) {
-                            sim->vip.xp.overtime = 1;
+                        sim->vip.dp.buffer  ^= sim->vip.xp.toggle;
-                            vipThrow(sim, 0x8000); /* TIMEERR */
+                        sim->vip.xp.enabled  = 1;
-                        }
+                        sim->vip.xp.overtime = 0;
+                        sim->vip.xp.step     = 1;
+                        sim->vip.xp.toggle   = 0;
+                    }
 
-                    } else sim->vip.xp.frame++;
                 }
 
+                /* Not a game frame */
+                else sim->vip.xp.frame++;
+
                 break;
 
             /* 0ms-3ms - Idle */
@@ -765,6 +768,7 @@ static int vipEmulateDisplay(VB *sim, uint32_t clocks) {
             /* 18ms-20ms - Idle */
 
             case 8: /* 20ms - Display interval complete */
+                sim->vip.buffer ^= 1;
                 sim->vip.dp.step = 0;
                 if (vipOnFrame(sim))
                     return 1;
@@ -1262,6 +1266,7 @@ static void vipEmulateDrawing(VB *sim, uint32_t clocks) {
             case 4: /* Drawing complete */
                 sim->vip.xp.enabled = 0;
                 sim->vip.xp.step    = 0;
+                sim->vip.xp.toggle  = 1;
                 if (sim->vip.dp.buffer == 0)
                      sim->vip.xp.f1bsy = 0;
                 else sim->vip.xp.f0bsy = 0;
@@ -1311,8 +1316,13 @@ static void vipRead(VB *sim, uint32_t address, int type, int32_t *value) {
         *value = 0;
 
     /* I/O register */
-    else if (address < 0x60000)
+    else if (address < 0x60000) {
         *value = vipReadIO(sim, address, type);
+        switch (type) {
+            case VB_S8 : *value = (int8_t ) *value; break;
+            case VB_S16: *value = (int16_t) *value; break;
+        }
+    }
 
     /* Unmapped */
     else if (address < 0x78000)
@@ -1328,11 +1338,11 @@ static void vipRead(VB *sim, uint32_t address, int type, int32_t *value) {
 
 /* Simulate a hardware reset */
 static void vipReset(VB *sim) {
-    Cell      *cell;  /* BG map cell state */
+    Cell      *cell;    /* BG map cell state */
-    Character *chr;   /* Character state */
+    Character *chr;     /* Character state */
-    Object    *obj;   /* Object state */
+    Object    *obj;     /* Object state */
-    World     *world; /* World state */
+    World     *world;   /* World state */
-    int        x, y;  /* Iterators */
+    int        x, y, z; /* Iterators */
 
     /* Normal */
     sim->vip.intenb   = 0x0000;
@@ -1422,6 +1432,13 @@ static void vipReset(VB *sim) {
     sim->vip.xp.sbcount  = 0;
     sim->vip.xp.sbout    = 0;
 
+    /* Other */
+    sim->vip.buffer = 0;
+    for (x = 0; x < 2; x++)
+    for (y = 0; y < 2; y++)
+    for (z = 0; z < 384*224; z++)
+        sim->vip.output[x][y][z] = 0;
+
     /* Display processor other */
     sim->vip.dp.brt[0] = 0;
     sim->vip.dp.buffer = 0; /* TODO: Hardware might actually do this */
@@ -1432,6 +1449,7 @@ static void vipReset(VB *sim) {
     /* Pixel processor other */
     sim->vip.xp.clocks = 0;
     sim->vip.xp.step   = 0;
+    sim->vip.xp.toggle = 0;
     sim->vip.xp.until  = 0;
 }
 

util/disassembler.c

@@ -513,6 +513,8 @@ static int dasmLine(VB *sim, uint32_t *address, uint32_t pc,
     line->isPC       = *address == pc;
     for (x = 0; x < line->codeLength; x++)
         line->code[x] = vbRead(sim, *address + x, VB_U8);
+
+    /* Advance to the next instruction or PC, whichever is sooner */
     *address += pc != *address && pc - *address < line->codeLength ?
         pc - *address : line->codeLength;
 
@@ -657,6 +659,8 @@ static VBU_DasmLine* dasmDisassemble(VB *sim, uint32_t address,
         size = vbuCodeSize(sim, addr);
         if (address - addr < size)
             break;
+
+        /* Advance to the next instruction or PC, whichever is sooner */
         addr += addr != pc && pc - addr < size ? pc - addr : size;
     }
 

web/Core.js

@@ -87,11 +87,8 @@ new class Core {
             this.sims.set(sim.pointer, sim);
 
             // Video
-            sim.pixels = this.#noalloc(
+            sim.pixels = this.#getPixels(sim);
-                this.GetExtPixels(sim.pointer),
+            sim.image  = new ImageData(sim.pixels, 384, 224);
-                384*224*4, sim, "pixels", Uint8ClampedArray
-            );
-            sim.image = new ImageData(sim.pixels, 384, 224);
 
             // Audio
             sim.samples = this.#noalloc(
@@ -364,8 +361,10 @@ new class Core {
             this.mallocs.set(buffer.pointer, buffer);
             this.#updateTarget(buffer);
         }
-        for (let sim of this.sims)
+        for (let sim of this.sims.values()) {
-            sim.image = new ImageData(sim.pixels, 384, 224);
+            sim.pixels = this.#getPixels(sim);
+            sim.image  = new ImageData(sim.pixels, 384, 224);
+        }
     }
 
 
@@ -436,6 +435,14 @@ new class Core {
         this.Realloc(buffer.pointer, 0);
     }
 
+    // Register a sim's pixel buffer
+    #getPixels(sim) {
+        return this.#noalloc(
+            this.GetExtPixels(sim.pointer),
+            384*224*4, sim, "pixels", Uint8ClampedArray
+        );
+    }
+
     // Allocate memory in WebAssembly and register the buffer
     #malloc(count, target = null, assign = null, type = Uint8ClampedArray) {
         return this.#noalloc(