qemu-wasm: wire up the touchscreen and audio output

Touch: pebble_touch.c gains a browser injection path — the page writes
{seq, down, x, y} in display pixels with Atomics and an 8 ms
virtual-clock poll raises the touch IRQ on state changes, mirroring
the input-layer handler. Canvas pointer events drive it; verified in
Chromium by touch-scrolling the launcher.

Audio: the pebble_audio drain stub now mirrors every DATA sample into
a shared int16 ring with rate/volume/playing mirrors; the page drains
it into WebAudio on a 60 ms poll, scheduling buffers at a running
playhead. The context is created on the first canvas touch to satisfy
autoplay policies.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Pi1WErefJ7c6kXodajm25M
Signed-off-by: Eric Migicovsky <eric@repebble.com>

Author: Eric Migicovsky

tools/qemu-wasm/jit/overlay/hw/misc/pebble_audio.c

@@ -30,6 +30,10 @@
 #include "hw/core/qdev-properties.h"
 #include "hw/core/qdev-properties-system.h"
 
+#ifdef EMSCRIPTEN
+#include <emscripten/emscripten.h>
+#endif
+
 #define TYPE_PEBBLE_AUDIO "pebble-audio"
 OBJECT_DECLARE_SIMPLE_TYPE(PblAudio, PEBBLE_AUDIO)
 
@@ -68,6 +72,39 @@ struct PblAudio {
     char *audiodev; /* accepted and ignored */
 };
 
+#ifdef EMSCRIPTEN
+/* Browser playback: every sample the firmware pushes via DATA is also
+ * appended to this ring; the page drains it into WebAudio. Head/tail
+ * are free-running sample counters (index = counter % size). rate,
+ * volume and playing mirror the device registers so the page can
+ * (re)configure its AudioContext. */
+#define WASM_AUDIO_RING 32768
+
+static int16_t s_wasm_audio_buf[WASM_AUDIO_RING];
+static struct {
+    uint32_t buf, size;
+    uint32_t head, tail;
+    uint32_t rate, volume, playing;
+} s_wasm_audio_ctrl;
+
+EMSCRIPTEN_KEEPALIVE void *pebble_wasm_audio_ctrl(void)
+{
+    s_wasm_audio_ctrl.buf = (uint32_t)(uintptr_t)s_wasm_audio_buf;
+    s_wasm_audio_ctrl.size = WASM_AUDIO_RING;
+    return &s_wasm_audio_ctrl;
+}
+
+static void pbl_audio_wasm_push(int16_t sample)
+{
+    uint32_t head = s_wasm_audio_ctrl.head;
+    if (head - qatomic_load_acquire(&s_wasm_audio_ctrl.tail) >= WASM_AUDIO_RING) {
+        return; /* page not draining — drop */
+    }
+    s_wasm_audio_buf[head % WASM_AUDIO_RING] = sample;
+    qatomic_store_release(&s_wasm_audio_ctrl.head, head + 1);
+}
+#endif
+
 static void pbl_audio_update_irq(PblAudio *s)
 {
     qemu_set_irq(s->irq, (s->intstat & s->intctrl) != 0);
@@ -160,14 +197,23 @@ static void pbl_audio_write(void *opaque, hwaddr offset,
         } else {
             pbl_audio_stop(s);
         }
+#ifdef EMSCRIPTEN
+        s_wasm_audio_ctrl.playing = s->ctrl & 1;
+#endif
         break;
     case AUDIO_SAMPLERATE:
         s->samplerate = value;
+#ifdef EMSCRIPTEN
+        s_wasm_audio_ctrl.rate = s->samplerate;
+#endif
         break;
     case AUDIO_DATA:
         if (s->ring_count < RING_BUF_SAMPLES) {
             s->ring_count++;
         }
+#ifdef EMSCRIPTEN
+        pbl_audio_wasm_push((int16_t)(value & 0xffff));
+#endif
         break;
     case AUDIO_INTCTRL:
         s->intctrl = value & INT_BUFAVAIL;
@@ -179,6 +225,9 @@ static void pbl_audio_write(void *opaque, hwaddr offset,
         break;
     case AUDIO_VOLUME:
         s->volume = value & 0x7F;
+#ifdef EMSCRIPTEN
+        s_wasm_audio_ctrl.volume = s->volume;
+#endif
         break;
     default:
         qemu_log_mask(LOG_GUEST_ERROR,
@@ -206,6 +255,11 @@ static void pbl_audio_reset(DeviceState *dev)
     s->intctrl = 0;
     s->intstat = 0;
     s->volume = 100;
+#ifdef EMSCRIPTEN
+    s_wasm_audio_ctrl.rate = s->samplerate;
+    s_wasm_audio_ctrl.volume = s->volume;
+    s_wasm_audio_ctrl.playing = 0;
+#endif
     pbl_audio_update_irq(s);
 }
 

tools/qemu-wasm/jit/overlay/hw/misc/pebble_touch.c

@@ -17,12 +17,17 @@
 
 #include "qemu/osdep.h"
 #include "qemu/log.h"
+#include "qemu/timer.h"
 #include "hw/core/irq.h"
 #include "hw/core/sysbus.h"
 #include "hw/core/qdev-properties.h"
 #include "ui/console.h"
 #include "ui/input.h"
 
+#ifdef EMSCRIPTEN
+#include <emscripten/emscripten.h>
+#endif
+
 #define TYPE_PEBBLE_TOUCH "pebble-touch"
 OBJECT_DECLARE_SIMPLE_TYPE(PblTouch, PEBBLE_TOUCH)
 
@@ -51,8 +56,30 @@ struct PblTouch {
     uint32_t display_h;
 
     QemuInputHandlerState *input_handler;
+
+#ifdef EMSCRIPTEN
+    QEMUTimer *wasm_poll_timer;
+    uint32_t wasm_last_seq;
+#endif
 };
 
+#ifdef EMSCRIPTEN
+/* Browser touch injection: the page writes display-pixel coordinates
+ * and the finger state, then bumps seq with Atomics; an 8 ms
+ * virtual-clock poll applies changes exactly like input-layer events. */
+static struct {
+    uint32_t seq;
+    uint32_t down;
+    uint32_t x;
+    uint32_t y;
+} s_wasm_touch;
+
+EMSCRIPTEN_KEEPALIVE void *pebble_wasm_touch_ctrl(void)
+{
+    return &s_wasm_touch;
+}
+#endif
+
 static void pbl_touch_update_irq(PblTouch *s)
 {
     qemu_set_irq(s->irq, (s->intctrl & INT_TOUCH_EVENT) &&
@@ -95,6 +122,32 @@ static const QemuInputHandler pbl_touch_input_handler = {
     .event = pbl_touch_input_event,
 };
 
+#ifdef EMSCRIPTEN
+static void pbl_touch_wasm_poll(void *opaque)
+{
+    PblTouch *s = opaque;
+    uint32_t seq = qatomic_load_acquire(&s_wasm_touch.seq);
+
+    if (seq != s->wasm_last_seq) {
+        s->wasm_last_seq = seq;
+        uint32_t down = s_wasm_touch.down ? 1 : 0;
+        uint32_t x = MIN(s_wasm_touch.x, s->display_w - 1);
+        uint32_t y = MIN(s_wasm_touch.y, s->display_h - 1);
+        bool changed = (down != s->state) ||
+                       (down && (x != s->x || y != s->y));
+        s->x = x;
+        s->y = y;
+        s->state = down;
+        if (changed) {
+            s->intstat |= INT_TOUCH_EVENT;
+            pbl_touch_update_irq(s);
+        }
+    }
+    timer_mod(s->wasm_poll_timer,
+              qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 8);
+}
+#endif
+
 /* === Register access === */
 
 static uint64_t pbl_touch_read(void *opaque, hwaddr offset, unsigned size)
@@ -157,6 +210,13 @@ static void pbl_touch_realize(DeviceState *dev, Error **errp)
     s->input_handler = qemu_input_handler_register(dev,
                                                     &pbl_touch_input_handler);
     qemu_input_handler_activate(s->input_handler);
+
+#ifdef EMSCRIPTEN
+    s->wasm_poll_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
+                                      pbl_touch_wasm_poll, s);
+    timer_mod(s->wasm_poll_timer,
+              qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 8);
+#endif
 }
 
 static void pbl_touch_init(Object *obj)

tools/qemu-wasm/site-dist/index.html

@@ -119,7 +119,7 @@ <h1>PebbleOS Emulator</h1>
     <button id="btn-select" title="Select (Right / Enter)">Select</button>
     <button id="btn-down" title="Down (Arrow Down)">Down</button>
   </div>
-  <div class="hint">Keys: &larr; Back &middot; &uarr;/&darr; Navigate &middot; &rarr;/Enter Select &middot; buttons can be held</div>
+  <div class="hint">Keys: &larr; Back &middot; &uarr;/&darr; Navigate &middot; &rarr;/Enter Select &middot; buttons can be held &middot; the screen is a touchscreen (click/drag)</div>
 
   <div id="install-panel">
     <div id="install-row">
@@ -344,6 +344,101 @@ <h1>PebbleOS Emulator</h1>
       el.addEventListener('pointercancel', release);
     });
 
+    // ================================================================
+    // Touch: pebble_touch.c polls a shared {seq, down, x, y} struct at
+    // 8 ms (display-pixel coordinates). Pointer events on the canvas
+    // write it with Atomics. Emery/gabbro only; harmless elsewhere.
+    // ================================================================
+    var touchAddr = 0;
+
+    function sendTouch(down, ev) {
+      if (!qemu) return;
+      if (!touchAddr) {
+        if (typeof qemu._pebble_wasm_touch_ctrl !== 'function') return;
+        touchAddr = Number(qemu._pebble_wasm_touch_ctrl());
+        if (!touchAddr) return;
+      }
+      var r = canvas.getBoundingClientRect();
+      var x = Math.max(0, Math.min(canvas.width - 1,
+        Math.round((ev.clientX - r.left) * canvas.width / r.width)));
+      var y = Math.max(0, Math.min(canvas.height - 1,
+        Math.round((ev.clientY - r.top) * canvas.height / r.height)));
+      var base = touchAddr >> 2;
+      Atomics.store(qemu.HEAPU32, base + 1, down ? 1 : 0);
+      Atomics.store(qemu.HEAPU32, base + 2, x);
+      Atomics.store(qemu.HEAPU32, base + 3, y);
+      Atomics.add(qemu.HEAPU32, base, 1);  // seq++ publishes the update
+    }
+
+    var touchActive = false;
+    canvas.style.touchAction = 'none';
+    canvas.addEventListener('pointerdown', function (e) {
+      e.preventDefault();
+      canvas.setPointerCapture(e.pointerId);
+      touchActive = true;
+      startAudio();  // user gesture: safe moment to unlock WebAudio
+      sendTouch(true, e);
+    });
+    canvas.addEventListener('pointermove', function (e) {
+      if (touchActive) sendTouch(true, e);
+    });
+    function touchEnd(e) {
+      if (!touchActive) return;
+      touchActive = false;
+      sendTouch(false, e);
+    }
+    canvas.addEventListener('pointerup', touchEnd);
+    canvas.addEventListener('pointercancel', touchEnd);
+
+    // ================================================================
+    // Audio: pebble_audio.c mirrors every PCM sample the firmware
+    // plays into a shared int16 ring; drain it into WebAudio on a
+    // 60 ms poll, scheduling chunks at a running playhead.
+    // ================================================================
+    var audioCtx = null;
+    var audioPlayhead = 0;
+    var audioAddr = 0;
+
+    function startAudio() {
+      if (audioCtx || !qemu) return;
+      if (typeof qemu._pebble_wasm_audio_ctrl !== 'function') return;
+      audioAddr = Number(qemu._pebble_wasm_audio_ctrl());
+      if (!audioAddr) return;
+      try {
+        audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+      } catch (e) { return; }
+      setInterval(drainAudio, 60);
+      log('[audio] output enabled');
+    }
+
+    function drainAudio() {
+      if (!audioCtx || audioCtx.state === 'suspended') { if (audioCtx) audioCtx.resume(); }
+      var base = audioAddr >> 2;
+      var u32 = qemu.HEAPU32;
+      var buf = u32[base], size = u32[base + 1];
+      var head = Atomics.load(u32, base + 2);
+      var tail = Atomics.load(u32, base + 3);
+      if (head === tail) return;
+      var n = (head - tail) >>> 0;
+      if (n > size) { tail = head - size; n = size; }
+      var rate = u32[base + 4] || 16000;
+      var vol = (u32[base + 5] || 100) / 100;
+      var pcm = audioCtx.createBuffer(1, n, Math.max(3000, rate));
+      var ch = pcm.getChannelData(0);
+      var heap16 = new Int16Array(qemu.HEAPU8.buffer);
+      for (var i = 0; i < n; i++) {
+        ch[i] = (heap16[(buf >> 1) + ((tail + i) % size)] / 32768) * vol;
+      }
+      Atomics.store(u32, base + 3, head);
+      var src = audioCtx.createBufferSource();
+      src.buffer = pcm;
+      src.connect(audioCtx.destination);
+      var now = audioCtx.currentTime;
+      if (audioPlayhead < now + 0.02) audioPlayhead = now + 0.02;
+      src.start(audioPlayhead);
+      audioPlayhead += n / Math.max(3000, rate);
+    }
+
     // ================================================================
     // Serial console: UART2 (debug console) is routed to a file in the
     // emscripten MEMFS; poll it and show printable text.