Aid VSU performance

core/cpu.c

@@ -91,11 +91,6 @@
 #define CPU_XORBSU   82
 #define CPU_XORNBSU  83
 
-/* Functional operand types */
-#define CPU_LITERAL  0
-#define CPU_MEMORY   1
-#define CPU_REGISTER 2
-
 /* Bit string operations */
 #define CPU_AND_BS  0
 #define CPU_ANDN_BS 1

core/vb.c

@@ -64,7 +64,9 @@ typedef struct {
     } wave;
 
     /* Other state */
-    uint32_t clocks; /* Clocks until next sample */
+    uint32_t clocks;  /* Clocks until next wave or noise sample */
+    uint8_t  freqmod; /* Frequency modifications are active */
+    uint32_t until;   /* Clocks until channel component update */
 } Channel;
 
 /* Simulation state */
@@ -643,6 +645,7 @@ VBAPI vbOnWrite vbGetWriteCallback(VB *sim) {
 VBAPI VB* vbInit(VB *sim) {
     sim->cart.ram        = NULL;
     sim->cart.rom        = NULL;
+    sim->ph.enabled      = 0;
     sim->vsu.out.samples = NULL;
     sim->onExecute       = NULL;
     sim->onFetch         = NULL;
@@ -652,7 +655,7 @@ VBAPI VB* vbInit(VB *sim) {
     sim->onSamples       = NULL;
     sim->onWrite         = NULL;
     sim->peer            = NULL;
-    sim->ph.enabled      = 0;
+    sim->tag             = NULL;
     vbReset(sim);
     return sim;
 }
@@ -716,28 +719,28 @@ VBAPI int vbSetCartROM(VB *sim, void *rom, uint32_t size) {
 /* Specify a new exception callback handler */
 VBAPI vbOnException vbSetExceptionCallback(VB *sim, vbOnException callback) {
     vbOnException prev = sim->onException;
-    sim->onException = callback;
+    sim->onException   = callback;
     return prev;
 }
 
 /* Specify a new execute callback handler */
 VBAPI vbOnExecute vbSetExecuteCallback(VB *sim, vbOnExecute callback) {
     vbOnExecute prev = sim->onExecute;
-    sim->onExecute = callback;
+    sim->onExecute   = callback;
     return prev;
 }
 
 /* Specify a new fetch callback handler */
 VBAPI vbOnFetch vbSetFetchCallback(VB *sim, vbOnFetch callback) {
     vbOnFetch prev = sim->onFetch;
-    sim->onFetch = callback;
+    sim->onFetch   = callback;
     return prev;
 }
 
 /* Specify a new frame callback handler */
 VBAPI vbOnFrame vbSetFrameCallback(VB *sim, vbOnFrame callback) {
     vbOnFrame prev = sim->onFrame;
-    sim->onFrame = callback;
+    sim->onFrame   = callback;
     return prev;
 }
 
@@ -749,7 +752,7 @@ VBAPI uint16_t vbSetKeys(VB *sim, uint16_t keys) {
 /* Specify a new link callback handler */
 VBAPI vbOnLink vbSetLinkCallback(VB *sim, vbOnLink callback) {
     vbOnLink prev = sim->onLink;
-    sim->onLink = callback;
+    sim->onLink   = callback;
     return prev;
 }
 
@@ -774,6 +777,8 @@ VBAPI int vbSetOption(VB *sim, int key, int value) {
 VBAPI void vbSetPeer(VB *sim, VB *peer) {
     if (sim->peer == peer)
         return;
+    if (sim->peer != NULL)
+        sim->peer->peer = NULL;
     sim->peer = peer;
     if (peer == NULL)
         return;
@@ -784,6 +789,7 @@ VBAPI void vbSetPeer(VB *sim, VB *peer) {
 
 /* Specify a new value for the program counter */
 VBAPI uint32_t vbSetProgramCounter(VB *sim, uint32_t value) {
+    sim->cpu.clocks    = 0;
     sim->cpu.operation = CPU_FETCH;
     sim->cpu.pc        = sim->cpu.nextPC = value & 0xFFFFFFFE;
     sim->cpu.step      = 0;
@@ -798,7 +804,7 @@ VBAPI int32_t vbSetProgramRegister(VB *sim, unsigned index, int32_t value) {
 /* Specify a new read callback handler */
 VBAPI vbOnRead vbSetReadCallback(VB *sim, vbOnRead callback) {
     vbOnRead prev = sim->onRead;
-    sim->onRead = callback;
+    sim->onRead   = callback;
     return prev;
 }
 
@@ -829,7 +835,7 @@ VBAPI uint32_t vbSetSystemRegister(VB *sim, unsigned index, uint32_t value) {
 /* Specify a new write callback handler */
 VBAPI vbOnWrite vbSetWriteCallback(VB *sim, vbOnWrite callback) {
     vbOnWrite prev = sim->onWrite;
-    sim->onWrite = callback;
+    sim->onWrite   = callback;
     return prev;
 }
 
@@ -841,7 +847,7 @@ VBAPI size_t vbSizeOf() {
 /* Specify a simulation's userdata pointer */
 VBAPI void* vbSetUserData(VB *sim, void *tag) {
     void *prev = sim->tag;
-    sim->tag = tag;
+    sim->tag   = tag;
     return prev;
 }
 

core/vsu.c

@@ -74,100 +74,57 @@ static void vsuNextFreqMod(VB *sim, Channel *chan) {
 }
 
 /* Process one channel */
-static void vsuEmulateChannel(VB *sim, int index, uint32_t clocks) {
+static void vsuEmulateChannel(VB *sim, Channel *chan, uint32_t clocks) {
-    uint32_t bit;     /* Pseudorandom bit */
+    uint32_t bit; /* Pseudorandom bit */
-    Channel *chan;    /* Channel handle */
-    int      freqmod; /* Frequency modifications enabled */
-    uint32_t until;   /* Clocks to process sub-channel components */
 
-    /* Select channel */
+    /* Automatic shutoff */
-    chan = &sim->vsu.channels[index];
+    if (chan->int_.auto_ && chan->int_.clocks == 0) {
-
+        chan->int_.enb = 0;
-    /* Channel is disabled */
-    if (!chan->int_.enb)
         return;
+    }
 
-    /* Frequency modifications are active */
+    /* Next input sample */
-    freqmod =
+    if (chan->clocks == 0) {
-        index == 4           &&        /* Channel 5 */
-        sim->vsu.freqmod.enb &&        /* Modifications enabled */
-        sim->vsu.freqmod.interval != 0 /* Modifications valid */
-    ;
 
-    /* Process all clocks */
+        /* Wave */
-    do {
+        if (chan != &sim->vsu.channels[5]) {
+            chan->clocks =  4 * (2048 - (uint32_t) chan->freq.current);
+            chan->wave.sample = (chan->wave.sample + 1) & 31;
+        }
 
-        /* Clocks until next state change */
+        /* Noise */
-        until = clocks;
+        else {
-        if (chan->clocks < until)
+            chan->clocks = 40 * (2048 - (uint32_t) chan->freq.current);
-            until = chan->clocks;
+            bit = ((
-        if (chan->env.enb && chan->env.clocks < until)
+                sim->vsu.noise.register_ >> NOISE_TAPS[sim->vsu.noise.tap]^
-            until = chan->env.clocks;
+                sim->vsu.noise.register_ >> 7
-        if (chan->int_.auto_ && chan->int_.clocks < until)
+            ) & 1) ^ 1;
-            until = chan->int_.clocks;
+            sim->vsu.noise.register_ = bit |
-        if (freqmod && sim->vsu.freqmod.clocks < until)
+                (sim->vsu.noise.register_ << 1 & 0x7FFE);
-            until = sim->vsu.freqmod.clocks;
+        }
 
-        /* Manage clocks */
+    }
-        clocks       -= until;
-        chan->clocks -= until;
-        if (chan->env.enb)
-            chan->env.clocks -= until;
-        if (chan->int_.auto_)
-            chan->int_.clocks -= until;
-        if (freqmod)
-            sim->vsu.freqmod.clocks -= until;
 
-        /* Automatic shutoff */
+    /* Envelope modification */
-        if (chan->int_.auto_ && chan->int_.clocks == 0) {
+    if (chan->env.enb && chan->env.clocks == 0) {
-            chan->int_.enb = 0;
+        if (chan->env.dir == 0 && chan->env.value != 0)
+            chan->env.value--;
+        else if (chan->env.dir == 1 && chan->env.value != 15)
+            chan->env.value++;
+        else if (chan->env.rep)
+            chan->env.value = chan->env.reload;
+        chan->env.clocks = ((uint32_t) chan->env.interval + 1) * 307220;
+    }
+
+    /* Frequency modification */
+    if (chan->freqmod && sim->vsu.freqmod.clocks == 0) {
+        chan->freq.current = sim->vsu.freqmod.next;
+        vsuNextFreqMod(sim, chan);
+        if (!chan->int_.enb)
             return;
-        }
+        sim->vsu.freqmod.clocks = (uint32_t) sim->vsu.freqmod.interval *
-
+            (sim->vsu.freqmod.clk == 0 ? 19200 : 153600);
-        /* Next sample */
+    }
-        if (chan->clocks == 0) {
-
-            /* Wave */
-            if (index != 5) {
-                chan->clocks =  4 * (2048 - (uint32_t) chan->freq.current);
-                chan->wave.sample = (chan->wave.sample + 1) & 31;
-            }
-
-            /* Noise */
-            else {
-                chan->clocks = 40 * (2048 - (uint32_t) chan->freq.current);
-                bit = ((
-                    sim->vsu.noise.register_ >> NOISE_TAPS[sim->vsu.noise.tap]^
-                    sim->vsu.noise.register_ >> 7
-                ) & 1) ^ 1;
-                sim->vsu.noise.register_ = bit |
-                    (sim->vsu.noise.register_ << 1 & 0x7FFE);
-            }
-
-        }
-
-        /* Envelope modification */
-        if (chan->env.enb && chan->env.clocks == 0) {
-            if (chan->env.dir == 0 && chan->env.value != 0)
-                chan->env.value--;
-            else if (chan->env.dir == 1 && chan->env.value != 15)
-                chan->env.value++;
-            else if (chan->env.rep)
-                chan->env.value = chan->env.reload;
-            chan->env.clocks = ((uint32_t) chan->env.interval + 1) * 307220;
-        }
-
-        /* Frequency modification */
-        if (freqmod && sim->vsu.freqmod.clocks == 0) {
-            chan->freq.current = sim->vsu.freqmod.next;
-            vsuNextFreqMod(sim, chan);
-            if (!chan->int_.enb)
-                return;
-            sim->vsu.freqmod.clocks = (uint32_t) sim->vsu.freqmod.interval *
-                (sim->vsu.freqmod.clk == 0 ? 19200 : 153600);
-        }
-
-    } while (clocks != 0);
 
 }
 
@@ -230,6 +187,8 @@ static void vsuWriteEV1(VB *sim, int index, uint8_t value) {
             sim->vsu.freqmod.func = value >> 4 & 1;
             sim->vsu.freqmod.rep  = value >> 5 & 1;
             vsuNextFreqMod(sim, chan);
+            chan->freqmod =
+                sim->vsu.freqmod.enb && sim->vsu.freqmod.interval != 0;
             break;
 
         case 5: /* Channel 6 */
@@ -313,6 +272,8 @@ static void vsuWriteSWP(VB *sim, uint8_t value) {
         (sim->vsu.freqmod.clk == 0 ? 19200 : 153600);
     if (clocks < sim->vsu.freqmod.clocks)
         sim->vsu.freqmod.clocks = clocks;
+    sim->vsu.channels[4].freqmod =
+        sim->vsu.freqmod.enb && sim->vsu.freqmod.interval != 0;
 }
 
 
@@ -321,6 +282,8 @@ static void vsuWriteSWP(VB *sim, uint8_t value) {
 
 /* Process component */
 static void vsuEmulate(VB *sim, uint32_t clocks) {
+    Channel *chan;      /* Input channel */
+    uint32_t chantil;   /* Clocks until next channel state update */
     float    i0;        /* Current analog input sample */
     float    o0;        /* Current analog output sample */
     uint16_t output[2]; /* Digital output samples */
@@ -340,12 +303,54 @@ static void vsuEmulate(VB *sim, uint32_t clocks) {
         sim->vsu.clocks -= until;
 
         /* Process all channels */
-        for (x = 0; x < 6; x++)
+        for (x = 0; x < 6; x++) {
-            vsuEmulateChannel(sim, x, until);
+            chan    = &sim->vsu.channels[x];
+            chantil = until;
+
+            /* Process all clocks */
+            while (chan->int_.enb && chantil != 0) {
+
+                /* Determine when the next state change will occur */
+                if (chan->until == 0) {
+
+                    /* Clocks until next state change */
+                    chan->until = chan->clocks;
+                    if (chan->env.enb && chan->env.clocks < chan->until)
+                        chan->until = chan->env.clocks;
+                    if (chan->int_.auto_ && chan->int_.clocks < chan->until)
+                        chan->until = chan->int_.clocks;
+                    if (chan->freqmod && sim->vsu.freqmod.clocks < chan->until)
+                        chan->until = sim->vsu.freqmod.clocks;
+
+                    /* Manage clocks */
+                    chan->clocks -= chan->until;
+                    if (chan->env.enb)
+                        chan->env.clocks -= chan->until;
+                    if (chan->int_.auto_)
+                        chan->int_.clocks -= chan->until;
+                    if (chan->freqmod)
+                        sim->vsu.freqmod.clocks -= chan->until;
+                }
+
+                /* Manage clocks */
+                if (chan->until > chantil) {
+                    chan->until -= chantil;
+                    chantil      = 0;
+                } else {
+                    chantil     -= chan->until;
+                    chan->until  = 0;
+                }
+
+                /* Update channel state */
+                if (chan->until == 0)
+                    vsuEmulateChannel(sim, chan, chan->until);
+            }
+
+        }
 
         /* Wait for the current sample to finish */
         if (sim->vsu.clocks != 0)
-            continue;
+            return;
 
         /* Compute the output sample */
         output[0] = output[1] = 0;
@@ -416,6 +421,8 @@ static void vsuReset(VB *sim) {
     for (x = 0; x < 6; x++) {
         chan = &sim->vsu.channels[x];
         chan->clocks        = 0;
+        chan->freqmod       = 0;
+        chan->until         = 0;
         chan->env.clocks    = 0;
         chan->env.enb       = 0;
         chan->env.dir       = 0;