@daugasauron/dolly-host-microphone 0.0.0-stage → 0.1.4-rc.0

package/README.md

@@ -1,3 +1,4 @@
-# Temporary Holding Version
+# @daugasauron/dolly-host-microphone
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Dolly's `microphone@0` host module: the default microphone, behind the browser's permission prompt. Give the URL of its
+`module.json` to `boot()`'s `modules`; @daugasauron/dolly's README says how.

package/abi.mjs

@@ -0,0 +1,20 @@
+// Generated from host/microphone/dolly-microphone-0.wat, host/microphone/microphone.h, include/dolly/process.h.
+export const DOLLY_MICROPHONE_VERSION = 0;
+export const DOLLY_MICROPHONE_PROCESS_OP = 130;
+export const DOLLY_MICROPHONE_SLOTS = 1;
+export const DOLLY_MICROPHONE_REPLY_BYTES = 16392;
+export const DOLLY_MICROPHONE_PACKET_BYTES = 40;
+export const DOLLY_MICROPHONE_RATE = 48000;
+export const DOLLY_MICROPHONE_CHANNELS = 1;
+export const DOLLY_MICROPHONE_MAX_FRAMES = 4096;
+export const DOLLY_MICROPHONE_QUEUE_FRAMES = 96000;
+export const DOLLY_MICROPHONE_OPEN = 1;
+export const DOLLY_MICROPHONE_READ = 2;
+export const DOLLY_MICROPHONE_STATUS = 3;
+export const DOLLY_MICROPHONE_CLOSE = 4;
+export const DOLLY_MICROPHONE_WAITING = 1;
+export const DOLLY_MICROPHONE_CAPTURING = 2;
+export const DOLLY_MICROPHONE_DENIED = 3;
+export const DOLLY_MICROPHONE_UNAVAILABLE = 4;
+export const DOLLY_ERRNO = Object.freeze({ E2BIG: 1, EACCES: 2, EADDRINUSE: 3, EADDRNOTAVAIL: 4, EAFNOSUPPORT: 5, EAGAIN: 6, EALREADY: 7, EBADF: 8, EBADMSG: 9, EBUSY: 10, ECANCELED: 11, ECHILD: 12, ECONNABORTED: 13, ECONNREFUSED: 14, ECONNRESET: 15, EDEADLK: 16, EDESTADDRREQ: 17, EDOM: 18, EDQUOT: 19, EEXIST: 20, EFAULT: 21, EFBIG: 22, EHOSTUNREACH: 23, EIDRM: 24, EILSEQ: 25, EINPROGRESS: 26, EINTR: 27, EINVAL: 28, EIO: 29, EISCONN: 30, EISDIR: 31, ELOOP: 32, EMFILE: 33, EMLINK: 34, EMSGSIZE: 35, EMULTIHOP: 36, ENAMETOOLONG: 37, ENETDOWN: 38, ENETRESET: 39, ENETUNREACH: 40, ENFILE: 41, ENOBUFS: 42, ENODEV: 43, ENOENT: 44, ENOEXEC: 45, ENOLCK: 46, ENOLINK: 47, ENOMEM: 48, ENOMSG: 49, ENOPROTOOPT: 50, ENOSPC: 51, ENOSYS: 52, ENOTCONN: 53, ENOTDIR: 54, ENOTEMPTY: 55, ENOTRECOVERABLE: 56, ENOTSOCK: 57, ENOTTY: 59, ENXIO: 60, EOVERFLOW: 61, EOWNERDEAD: 62, EPERM: 63, EPIPE: 64, EPROTO: 65, EPROTONOSUPPORT: 66, EPROTOTYPE: 67, ERANGE: 68, EROFS: 69, ESPIPE: 70, ESRCH: 71, ESTALE: 72, ETIMEDOUT: 73, ETXTBSY: 74, EXDEV: 75, ENODATA: 116, ENOTSUP: 138 });
+export const DOLLY_MICROPHONE_ABI_DIGEST = "1e1a29020c1d2f288048903eb53d1807819f52264e6366a8f9a326483054e5b4";

package/microphone.mjs

@@ -0,0 +1,63 @@
+import { createMicrophoneProvider } from "./provider.mjs";
+import * as M from "./abi.mjs";
+import { DOLLY_ERRNO as E } from "./abi.mjs";
+export { DOLLY_MICROPHONE_ABI_DIGEST as digest } from "./abi.mjs";
+
+// The device as the lease bridge sees it.
+export const lease = { type: "microphone", slots: M.DOLLY_MICROPHONE_SLOTS, packetBytes: M.DOLLY_MICROPHONE_PACKET_BYTES,
+  replyBytes: M.DOLLY_MICROPHONE_REPLY_BYTES, open: M.DOLLY_MICROPHONE_OPEN, close: M.DOLLY_MICROPHONE_CLOSE };
+
+export function check() {
+  return typeof navigator.mediaDevices?.getUserMedia === "function" && typeof globalThis.AudioWorkletNode === "function"
+    ? null : "Microphone capture is unavailable in this browser";
+}
+
+// Trusted page DOM over the display, beside the browser's own recording mark:
+// shown for as long as a program has asked for or holds the microphone.
+function indicate(indicators, state) {
+  let element = document.querySelector("#microphone-status");
+  if (!element) {
+    element = document.body.appendChild(document.createElement("div"));
+    element.id = "microphone-status";
+    element.className = "page-indicator";
+    element.setAttribute("role", "status");
+    element.style.cssText = "position:fixed;left:0.5rem;bottom:2rem;z-index:8;max-width:calc(100vw - 1rem);" +
+      "padding:0.15rem 0.45rem;background:#262626;border:1px solid #e98773;color:#e98773;font-size:13px;pointer-events:none";
+  }
+  const text = { waiting: "Microphone: waiting for permission", capturing: "Microphone on" }[state];
+  element.hidden = !text;
+  element.textContent = text ?? "";
+  indicators.hold(element, Boolean(text));
+}
+
+export function browser({ send, indicators }) {
+  const provider = createMicrophoneProvider(() => indicate(indicators, provider.status().state));
+  return {
+    page: { get microphone() { return provider.status(); } },
+    messages: {
+      "microphone-request"(message) {
+        const result = provider.dispatch(message.packet);
+        send({ type: "microphone-complete", scope: message.scope, sequence: message.sequence, ...result },
+          [result.bytes.buffer]);
+      },
+      "microphone-revoke"(message) {
+        provider.release(message.scope);
+        send({ type: "microphone-complete", scope: message.scope, revoked: true });
+      },
+    },
+    dispose() { provider.close(); },
+  };
+}
+
+export function worker({ send, get }) {
+  let bridge;
+  return {
+    bindings: { "env.dolly_microphone_dispatch": (address, bytes) =>
+      bridge ? bridge.dispatch({ address, bytes }) : -E.ENOSYS },
+    start({ kernel }) {
+      bridge = get("runtime").leaseBridge(lease, Number(kernel.dolly_microphone_mailbox_address()), send);
+    },
+    messages: { "microphone-complete": message => bridge?.acknowledge(message) },
+    dispose() { bridge?.dispose(); bridge = undefined; },
+  };
+}

package/module.json

@@ -0,0 +1,15 @@
+{
+  "name": "microphone",
+  "version": 0,
+  "gives": "the default microphone, behind the browser's permission prompt",
+  "dependencies": ["runtime@0"],
+  "phase": "kernel",
+  "imports": ["env.dolly_microphone_dispatch"],
+  "host": "microphone.mjs",
+  "contracts": ["dolly-microphone-0.wat"],
+  "process": [],
+  "headers": ["microphone.h", "microphone-abi.h"],
+  "kernel": ["kernel.c"],
+  "client": ["client.c"],
+  "package": "libdolly-microphone"
+}

package/package.json

@@ -1,6 +1,14 @@
 {
+  "version": "0.1.4-rc.0",
+  "type": "module",
   "name": "@daugasauron/dolly-host-microphone",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "license": "MIT",
+  "dependencies": {
+    "@daugasauron/dolly": "0.1.4-rc.0"
+  },
+  "description": "Dolly's microphone@0 host module: the default microphone, behind the browser's permission prompt.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daugasauron/dolly.git"
+  }
+}

package/provider.mjs

@@ -0,0 +1,132 @@
+import * as M from "./abi.mjs";
+import { DOLLY_ERRNO as E } from "./abi.mjs";
+
+const fail = errno => { throw Object.assign(new Error("Microphone request failed"), {errno}); };
+const response = size => new Uint8Array(size);
+const names = { [M.DOLLY_MICROPHONE_WAITING]: "waiting", [M.DOLLY_MICROPHONE_CAPTURING]: "capturing",
+  [M.DOLLY_MICROPHONE_DENIED]: "denied", [M.DOLLY_MICROPHONE_UNAVAILABLE]: "unavailable" };
+
+// The page side of microphone@0: one capture of the browser's default input.
+// OPEN asks the browser, whose own prompt decides; nothing here grants it.
+// `changed` runs whenever the capture's state does.
+export function createMicrophoneProvider(changed = () => {}) {
+  let capture, generation = 0;
+
+  function set(target, state) {
+    if (target.released || target.state === state) return;
+    target.state = state;
+    changed();
+  }
+  // Stops the tracks, which is what releases the device and ends the browser's own indicator.
+  function stop(target) {
+    if (target.node) { target.node.port.onmessage = null; target.node.disconnect(); }
+    target.source?.disconnect();
+    for (const track of target.stream?.getTracks() ?? []) track.stop();
+    if (target.context && target.context.state !== "closed") target.context.close().catch(() => {});
+  }
+  function queue(target, samples) {
+    if (target.released || !(samples instanceof Float32Array) || samples.length > target.samples.length) return;
+    const size = target.samples.length, overflow = Math.max(0, target.length + samples.length - size);
+    target.start = (target.start + overflow) % size;
+    target.length -= overflow; target.dropped += overflow;
+    const end = (target.start + target.length) % size, first = Math.min(samples.length, size - end);
+    target.samples.set(samples.subarray(0, first), end);
+    target.samples.set(samples.subarray(first), 0);
+    target.length += samples.length; target.captured += samples.length;
+  }
+  async function start(target) {
+    try {
+      target.stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: false });
+      if (target.released) return stop(target);
+      target.context = new AudioContext({ sampleRate: M.DOLLY_MICROPHONE_RATE });
+      await target.context.audioWorklet.addModule(new URL("./worklet.mjs", import.meta.url));
+      if (target.released) return stop(target);
+      target.source = target.context.createMediaStreamSource(target.stream);
+      target.node = new AudioWorkletNode(target.context, "dolly-microphone", { numberOfInputs: 1, numberOfOutputs: 0,
+        channelCount: M.DOLLY_MICROPHONE_CHANNELS, channelCountMode: "explicit", channelInterpretation: "speakers" });
+      target.node.port.onmessage = event => queue(target, event.data);
+      target.source.connect(target.node);
+      for (const track of target.stream.getAudioTracks()) {
+        track.addEventListener("ended", () => set(target, M.DOLLY_MICROPHONE_UNAVAILABLE));
+      }
+      set(target, M.DOLLY_MICROPHONE_CAPTURING);
+      // A capture closed at once ends this promise in a rejection of its own making.
+      target.context.resume().catch(() => {});
+    } catch (error) {
+      const denied = error?.name === "NotAllowedError" || error?.name === "SecurityError";
+      if (!denied && error?.name !== "NotFoundError") console.warn("Dolly microphone:", error);
+      stop(target);
+      set(target, denied ? M.DOLLY_MICROPHONE_DENIED : M.DOLLY_MICROPHONE_UNAVAILABLE);
+    }
+  }
+  function release(scope) {
+    if (capture?.scope !== scope) return;
+    const target = capture;
+    capture = undefined;
+    target.released = true;
+    stop(target);
+    changed();
+  }
+  function status() {
+    return { active: capture ? 1 : 0, state: capture ? names[capture.state] : "closed",
+      queuedFrames: capture?.length ?? 0, capturedFrames: capture?.captured ?? 0, droppedFrames: capture?.dropped ?? 0,
+      liveTracks: capture?.stream?.getTracks().filter(track => track.readyState === "live").length ?? 0 };
+  }
+  function dispatch(packet) {
+    try {
+      if (!(packet instanceof Uint8Array) || packet.byteLength < 32 || packet.byteLength > M.DOLLY_MICROPHONE_PACKET_BYTES) fail(E.EINVAL);
+      packet = packet.slice();
+      const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+      const op = view.getUint32(4, true), scope = view.getUint32(8, true), sequence = view.getUint32(16, true);
+      if (view.getUint32(0, true) !== M.DOLLY_MICROPHONE_VERSION || view.getUint32(12, true) || view.getUint32(20, true) ||
+          !scope || !sequence || view.getUint32(24, true) !== packet.length - 32 || view.getUint32(28, true)) fail(E.EINVAL);
+      let result;
+      if (op === M.DOLLY_MICROPHONE_OPEN) {
+        if (packet.length !== 32) fail(E.EINVAL);
+        if (scope <= generation) fail(E.ESTALE);
+        if (capture) fail(E.EBUSY);
+        if (typeof navigator.mediaDevices?.getUserMedia !== "function" || typeof AudioWorkletNode !== "function") fail(E.ENOSYS);
+        capture = { scope, sequence, state: M.DOLLY_MICROPHONE_WAITING, released: false,
+          samples: new Float32Array(M.DOLLY_MICROPHONE_QUEUE_FRAMES), start: 0, length: 0, captured: 0, dropped: 0 };
+        generation = scope;
+        void start(capture);
+        changed();
+        result = response(16);
+        const output = new DataView(result.buffer);
+        output.setBigUint64(0, BigInt(scope), true);
+        output.setUint32(8, M.DOLLY_MICROPHONE_RATE, true); output.setUint32(12, M.DOLLY_MICROPHONE_CHANNELS, true);
+      } else {
+        if (capture?.scope !== scope) fail(E.EBADF);
+        if (sequence <= capture.sequence) fail(E.ESTALE);
+        capture.sequence = sequence;
+        if (op === M.DOLLY_MICROPHONE_READ) {
+          if (packet.length !== 40) fail(E.EINVAL);
+          const frames = view.getUint32(32, true);
+          if (!frames || frames > M.DOLLY_MICROPHONE_MAX_FRAMES || view.getUint32(36, true)) fail(E.EINVAL);
+          const count = Math.min(frames, capture.length), size = capture.samples.length;
+          if (!count && capture.state === M.DOLLY_MICROPHONE_DENIED) fail(E.EACCES);
+          if (!count && capture.state === M.DOLLY_MICROPHONE_UNAVAILABLE) fail(E.ENODEV);
+          result = response(8 + count * 4);
+          const output = new DataView(result.buffer);
+          output.setUint32(0, count, true); output.setUint32(4, capture.state, true);
+          for (let i = 0; i < count; ++i) output.setFloat32(8 + i * 4, capture.samples[(capture.start + i) % size], true);
+          capture.start = (capture.start + count) % size; capture.length -= count;
+        } else if (op === M.DOLLY_MICROPHONE_STATUS) {
+          if (packet.length !== 32) fail(E.EINVAL);
+          result = response(24);
+          const output = new DataView(result.buffer);
+          output.setUint32(0, capture.length, true); output.setUint32(4, capture.state, true);
+          output.setBigUint64(8, BigInt(capture.captured), true); output.setBigUint64(16, BigInt(capture.dropped), true);
+        } else if (op === M.DOLLY_MICROPHONE_CLOSE) {
+          if (packet.length !== 32) fail(E.EINVAL);
+          release(scope); result = response(0);
+        } else fail(E.ENOSYS);
+      }
+      return {bytes: result, error: 0};
+    } catch (error) {
+      if (!error.errno) console.warn("Dolly microphone:", error);
+      return {bytes: response(0), error: error.errno ?? E.EIO};
+    }
+  }
+  return {dispatch, release, status, close() { if (capture) release(capture.scope); }};
+}

package/worklet.mjs

@@ -0,0 +1,19 @@
+// The audio thread's side of microphone@0: hands the page the input's samples,
+// 1024 frames at a time. The node mixes the input down to one channel.
+class DollyMicrophone extends AudioWorkletProcessor {
+  block = new Float32Array(1024);
+  filled = 0;
+  process([[channel]]) {
+    for (let at = 0; channel && at < channel.length;) {
+      const count = Math.min(channel.length - at, this.block.length - this.filled);
+      this.block.set(channel.subarray(at, at + count), this.filled);
+      this.filled += count; at += count;
+      if (this.filled === this.block.length) {
+        this.port.postMessage(this.block, [this.block.buffer]);
+        this.block = new Float32Array(1024); this.filled = 0;
+      }
+    }
+    return true;
+  }
+}
+registerProcessor("dolly-microphone", DollyMicrophone);