buninu-browser 0.2.3 → 0.2.4

package/lib/renderer/main.js

@@ -46,6 +46,7 @@ import { RENDERER_LOG_FLAG } from "../log.js";
 import wasmpeg from "../../vendor/wasmpeg/src/js/index.js";
 import { createBytePipe } from "../media/byte-pipe.js";
 import { notifyRejectionHandled, notifyUnhandledRejection } from "./rejections.js";
+import { SharedFramePool } from "../paint/shared-frame-pool.js";
 
 const DANGEROUSLY_ALLOW_HOST_JS = "--dangerously-allow-host-js";
 
@@ -90,6 +91,7 @@ function fetchResource(url, kind) {
 function pageFetch(request) {
   let fetchId;
   let streamController;
+  const completed = Promise.withResolvers();
   const body = new ReadableStream({
     start(controller) { streamController = controller; },
     cancel() { promise.abort(); },
@@ -97,11 +99,17 @@ function pageFetch(request) {
   const promise = new Promise((resolve, reject) => {
     const id = nextFetchId++;
     fetchId = id;
-    pendingFetches.set(id, { resolve, reject, page: true, body, streamController, head: false });
+    pendingFetches.set(id, { resolve, reject, page: true, body, streamController, head: false, finish: completed.resolve });
     process.send({ type: "page-fetch", id, request });
   });
-  promise.abort = () => {
-    if (!pendingFetches.delete(fetchId)) return;
+  promise.finished = completed.promise;
+  promise.abort = (reason = new DOMException("The operation was aborted.", "AbortError")) => {
+    const pending = pendingFetches.get(fetchId);
+    if (!pending) return;
+    pendingFetches.delete(fetchId);
+    if (pending.head) { try { streamController.error(reason); } catch {} }
+    else pending.reject(reason);
+    completed.resolve();
     process.send({ type: "page-fetch-abort", id: fetchId });
   };
   return promise;
@@ -145,6 +153,7 @@ const audio = {
 };
 
 // Workers load their module from disk, so this happens before seccomp.
+const frameBuffers = new SharedFramePool();
 const compositor = process.argv.includes(COMPOSITOR_FLAG) ? await startCompositor() : null;
 // Started before the sandbox closes: the worker loads its module from disk.
 const rewriteScript = await startScriptRewriter();
@@ -167,9 +176,17 @@ async function startCompositor() {
     worker.addEventListener("message", resolve, { once: true });
     worker.addEventListener("error", reject, { once: true });
   });
+  worker.addEventListener("error", (event) => {
+    frameBuffers.clear();
+    report(`buninu-browser: compositor worker failed: ${String(event?.message ?? "unknown error").slice(0, 500)}`);
+    // Its dedicated controller channel and outstanding frame leases cannot
+    // recover in place. Normal renderer exit rejects pending controller calls.
+    process.exit(1);
+  });
   worker.addEventListener("message", ({ data }) => {
     if (data?.type === "scroll") renderer.applyCompositorScroll(data.x, data.y);
     else if (data?.type === "video-report") renderer.videoReport(data);
+    else if (data?.type === "frame-release" && Number.isInteger(data.serial)) frameBuffers.release(data.serial);
     else if (data?.type === "frame-ack" && Number.isInteger(data.serial)) {
       framesAcknowledged = Math.max(framesAcknowledged, data.serial);
       frameWaiters = frameWaiters.filter((waiter) => {
@@ -232,7 +249,12 @@ const renderer = await createPageRenderer({
   reportError: (message) => report(`buninu-browser: page error: ${logging ? message : String(message).split("\n")[0]}`),
   consoleMessage: logging ? (level, text) => report(`page console.${level}: ${text}`) : null,
   trace: logging ? (text) => report(`timing: ${text}`) : null,
-  onFrame: compositor ? (frame) => compositor.postMessage({ type: "frame", serial: ++framesSent, ...frame }) : null,
+  allocateFramePixels: compositor ? bytes => frameBuffers.acquire(bytes) : null,
+  onFrame: compositor ? (frame) => {
+    const serial = ++framesSent;
+    frameBuffers.publish(serial, frame.tile.pixels);
+    compositor.postMessage({ type: "frame", serial, ...frame });
+  } : null,
   onVideo: compositor ? (message) => compositor.postMessage(message) : null,
   // Whoever waits for load (a screenshot, say) sees the frame painted at load.
   onLifecycle: (name, generation) => {
@@ -317,6 +339,7 @@ process.on("message", async (message) => {
     if (!pending?.page) return;
     pendingFetches.delete(message.id);
     pending.streamController.close();
+    pending.finish?.();
     return;
   }
   if (message?.type === "page-fetch-error") {
@@ -326,6 +349,7 @@ process.on("message", async (message) => {
     const error = new Error(message.error || "fetch failed");
     if (pending.head) pending.streamController.error(error);
     else pending.reject(error);
+    pending.finish?.();
     return;
   }
   if (message?.type === "fetch-chunk") {
@@ -357,6 +381,7 @@ process.on("message", async (message) => {
       const error = new Error(message.error);
       pending.pipe?.fail(error);
       if (!pending.head) pending.reject(error);
+      pending.finish?.();
       return;
     }
     const result = message.result ?? {};
@@ -374,6 +399,7 @@ process.on("message", async (message) => {
       return;
     }
     pending.resolve(result);
+    pending.finish?.();
     return;
   }
   if (message?.type === "audio-event") {

package/lib/renderer/media-source.js

@@ -5,14 +5,16 @@
  * The event order follows the Media Source spec: appendBuffer returns with
  * updating set, and a later task runs updatestart, the append, then update
  * and updateend. sourceopen fires when an element attaches, not at
- * construction. remove() and abort() do not cut bytes out of the
- * concatenation — splicing an fMP4 or WebM would break the container, and
- * the decoder reopens on the whole snapshot.
+ * construction. remove() and abort() retain original fragment history for
+ * decoder reopens and backward seeks. MP4 initialization changes have
+ * separate snapshots selected by media time, so configurations do not mix.
  *
  * Codec claims stay inside what this build can demux and decode. Types the
  * engine cannot play are rejected so a page picks another one.
  */
 import { createBytePipe } from "../media/byte-pipe.js";
+import { createSourceSnapshots } from "../media/source-snapshots.js";
+import { createWebMStream, ebmlHeader } from "../media/webm-stream.js";
 
 const BRAND = Symbol("MediaSource");
 const BUFFER_BRAND = Symbol("SourceBuffer");
@@ -140,53 +142,55 @@ function ebmlUint(bytes, offset, length) {
 }
 
 /** Actual buffered end of WebM clusters (nanosecond TimecodeScale, millisecond default). */
-function inspectWebMAppend(bytes, state) {
-  for (let offset = 0; offset + 4 < bytes.byteLength; offset++) {
-    if (bytes[offset] !== 0x2a || bytes[offset + 1] !== 0xd7 || bytes[offset + 2] !== 0xb1) continue;
-    const size = ebmlVint(bytes, offset + 3);
-    const value = size && ebmlUint(bytes, offset + 3 + size.length, size.value);
-    if (value) state.scale = value;
-  }
-  const scale = state.scale || 1_000_000;
+function inspectWebMAppend(bytes, state, clusterOrigin = null) {
   let latest = null;
   let first = null;
-  state.appendHasHeader = bytes.byteLength >= 4 && bytes[0] === 0x1a && bytes[1] === 0x45 && bytes[2] === 0xdf && bytes[3] === 0xa3;
-  for (let offset = 0; offset + 4 < bytes.byteLength;) {
-    if (!(bytes[offset] === 0x1f && bytes[offset + 1] === 0x43
-      && bytes[offset + 2] === 0xb6 && bytes[offset + 3] === 0x75)) {
-      offset++;
-      continue;
-    }
-    const size = ebmlVint(bytes, offset + 4);
-    if (!size) break;
-    let cursor = offset + 4 + size.length;
-    const limit = Math.min(bytes.byteLength, cursor + size.value);
-    let clusterTime = 0;
-    while (cursor < limit) {
-      const element = ebmlVint(bytes, cursor, true);
-      const length = element && ebmlVint(bytes, cursor + element.length);
-      if (!element || !length) break;
-      const data = cursor + element.length + length.length;
-      const end = Math.min(limit, data + length.value);
-      if (element.value === 0xe7) {
-        clusterTime = ebmlUint(bytes, data, length.value) ?? clusterTime;
-        first ??= clusterTime;
-        latest = Math.max(latest ?? 0, clusterTime);
-      } else if (element.value === 0xa3 || element.value === 0xa1) {
-        const track = ebmlVint(bytes, data);
-        const timeAt = track ? data + track.length : end;
-        if (timeAt + 2 <= end) {
-          let relative = (bytes[timeAt] << 8) | bytes[timeAt + 1];
-          if (relative & 0x8000) relative -= 0x10000;
-          // Opus packets are normally 20 ms; this small tail keeps buffered
-          // from ending at the start timestamp of its final packet.
-          latest = Math.max(latest ?? 0, clusterTime + relative + 20);
+  const tracks = new Map();
+  const inspectCluster = (from, limit, origin = 0) => {
+    let clusterTime = origin;
+    const visit = (start, stop) => {
+      for (let cursor = start; cursor < stop;) {
+        const element = ebmlHeader(bytes, cursor);
+        if (!element) break;
+        const data = cursor + element.length, end = Math.min(stop, data + element.size);
+        if (element.id === 0xe7) {
+          clusterTime = ebmlUint(bytes, data, element.size) ?? clusterTime;
+          latest = Math.max(latest ?? 0, clusterTime);
+        } else if (element.id === 0xa0) visit(data, end); // BlockGroup
+        else if (element.id === 0xa3 || element.id === 0xa1) {
+          const track = ebmlVint(bytes, data);
+          const timeAt = track ? data + track.length : end;
+          if (timeAt + 2 <= end) {
+            let relative = (bytes[timeAt] << 8) | bytes[timeAt + 1];
+            if (relative & 0x8000) relative -= 0x10000;
+            first = Math.min(first ?? clusterTime + relative, clusterTime + relative);
+            // Opus packets are normally 20 ms; include the final packet.
+            latest = Math.max(latest ?? 0, clusterTime + relative + 20);
+            const range = tracks.get(track.value);
+            tracks.set(track.value, [Math.min(range?.[0] ?? Infinity, clusterTime + relative),
+              Math.max(range?.[1] ?? 0, clusterTime + relative + 20)]);
+          }
         }
+        cursor = end;
       }
-      cursor = end;
+    };
+    visit(from, limit);
+  };
+  const visit = (from, limit) => {
+    for (let offset = from; offset < limit;) {
+      const element = ebmlHeader(bytes, offset);
+      if (!element) break;
+      const data = offset + element.length, end = Math.min(limit, data + element.size);
+      if (element.id === 0x18538067 || element.id === 0x1549a966) visit(data, end);
+      else if (element.id === 0x2ad7b1) state.scale = ebmlUint(bytes, data, element.size) || state.scale;
+      else if (element.id === 0x1f43b675) inspectCluster(data, end);
+      offset = end;
     }
-    offset = Math.max(offset + 4, limit);
-  }
+  };
+  if (clusterOrigin != null) inspectCluster(0, bytes.length, clusterOrigin);
+  else visit(0, bytes.length);
+  const scale = state.scale || 1_000_000;
+  state.appendTracks = new Map([...tracks].map(([track, [start, end]]) => [track, [start * scale / 1e9, end * scale / 1e9]]));
   state.appendStart = first == null ? null : first * scale / 1e9;
   return latest == null ? null : latest * scale / 1e9;
 }
@@ -422,7 +426,12 @@ export function createMediaSourceScope({ origin, schedule, DOMException, onAppen
       Object.defineProperty(this, BUFFER_BRAND, { value: true });
       this._source = source;
       this._mime = String(mime);
-      this._pipe = createBytePipe();
+      this._snapshots = /^(video|audio)\/mp4\b/i.test(this._mime) ? createSourceSnapshots(inspectMp4Append) : null;
+      this._pipe = createBytePipe({ retainBytes: !this._snapshots });
+      if (this._snapshots) {
+        this._pipe.snapshotAt = time => this._snapshots.at(time);
+        this._pipe.bytes = () => this._snapshots.at(0).bytes;
+      }
       this._updating = false;
       this._operation = 0;
       this._removed = false;
@@ -433,6 +442,8 @@ export function createMediaSourceScope({ origin, schedule, DOMException, onAppen
       this._accountedBytes = 0;
       this._mp4 = {};
       this._webm = {};
+      this._webmCovered = new Map();
+      this._webmStream = /^(video|audio)\/webm\b/i.test(this._mime) ? createWebMStream() : null;
       this._hasSegmentTimeline = false;
       this._hasMediaSegment = false;
       this._appendWindowStart = 0;
@@ -504,16 +515,12 @@ export function createMediaSourceScope({ origin, schedule, DOMException, onAppen
       const bytes = copyBytes(data);
       const inspected = /^video\/mp4|^audio\/mp4/i.test(this._mime) ? this._mp4
         : /^video\/webm|^audio\/webm/i.test(this._mime) ? this._webm : null;
-      const segmentEnd = inspected === this._mp4 ? inspectMp4Append(bytes, this._mp4)
-        : inspected === this._webm ? inspectWebMAppend(bytes, this._webm) : null;
+      let segmentEnd = inspected === this._mp4 ? inspectMp4Append(bytes, this._mp4) : null;
       // Media the buffer already holds, sent again (players retry a segment
       // on a slow network): the concatenation would play it twice, so it is
       // left out. Its events fire as for any append.
       const start = inspected && !inspected.appendHasHeader ? inspected.appendStart : null;
-      const duplicate = start != null && segmentEnd != null && covers(this._covered, start, segmentEnd);
-      const hasWebMCluster = /^video\/webm|^audio\/webm/i.test(this._mime)
-        && bytes.indexOf(0x1f) >= 0 && bytes.some((value, index) => value === 0x1f
-          && bytes[index + 1] === 0x43 && bytes[index + 2] === 0xb6 && bytes[index + 3] === 0x75);
+      const duplicate = !this._snapshots && start != null && segmentEnd != null && covers(this._covered, start, segmentEnd);
       if (appended + bytes.byteLength > appendQuota) {
         throw new DOMException("The SourceBuffer is full.", "QuotaExceededError");
       }
@@ -525,13 +532,15 @@ export function createMediaSourceScope({ origin, schedule, DOMException, onAppen
       schedule(() => {
         if (this._removed || operation !== this._operation) return;
         emitNow(this, "updatestart");
-        if (!duplicate) {
+        if (this._webmStream) {
+          segmentEnd = this._appendWebM(this._webmStream.append(bytes), bytes.length);
+        } else if (!duplicate && (!this._snapshots || this._snapshots.append(bytes))) {
           this._pipe.append(bytes);
           appended += bytes.byteLength;
           this._accountedBytes += bytes.byteLength;
           if (start != null && segmentEnd != null) addCovered(this._covered, start, segmentEnd);
         }
-        if (this._mp4.hasMediaSegment || hasWebMCluster) this._hasMediaSegment = true;
+        if (this._mp4.hasMediaSegment) this._hasMediaSegment = true;
         if (segmentEnd != null) {
           if (!this._hasSegmentTimeline) this._end = segmentEnd;
           else this._end = Math.max(this._end, segmentEnd);
@@ -548,10 +557,66 @@ export function createMediaSourceScope({ origin, schedule, DOMException, onAppen
       });
     }
 
+    /** Complete finite Clusters, or complete Blocks from an unknown-size
+     * live Cluster, enter the decoder and contribute buffered ranges.
+     * Retries may be split differently or share an append with new media;
+     * comparing complete elements handles both cases.
+     */
+    _appendWebM(elements, incoming = 0) {
+      let retained = incoming, latest = null;
+      for (const { id, bytes, cluster, closedCluster } of elements) {
+        if (closedCluster) {
+          if (!closedCluster.accepted) retained -= closedCluster.prefix.reduce((sum, part) => sum + part.length, 0);
+          continue;
+        }
+        const end = inspectWebMAppend(bytes, this._webm, cluster?.time);
+        const start = this._webm.appendStart;
+        if (id === 0x1f43b675) {
+          this._hasMediaSegment = true;
+          if (end != null) latest = Math.max(latest ?? end, end);
+          if (start != null && end != null) {
+            // Different tracks can carry samples at the same timestamp.
+            // In particular, incremental unknown-size Clusters expose one
+            // Block at a time; an audio Block must not discard a video Block.
+            const tracks = this._webm.appendTracks;
+            if (tracks.size && [...tracks].every(([track, range]) => covers(this._webmCovered.get(track) ?? [], ...range))) {
+              retained -= bytes.length; continue;
+            }
+            for (const [track, range] of tracks) {
+              if (!this._webmCovered.has(track)) this._webmCovered.set(track, []);
+              addCovered(this._webmCovered.get(track), ...range);
+            }
+            addCovered(this._covered, start, end);
+          }
+        }
+        if (cluster && this._webmCluster !== cluster.token) {
+          for (const prefix of cluster.prefix) this._pipe.append(prefix);
+          this._webmCluster = cluster.token;
+          cluster.token.accepted = true;
+        }
+        this._pipe.append(bytes);
+      }
+      // A retry can span remove(), which may already have released the
+      // quota charged for its first pieces. Refund only this buffer's
+      // remaining charge, never another SourceBuffer's bytes.
+      retained = Math.max(-this._accountedBytes, retained);
+      appended += retained;
+      this._accountedBytes += retained;
+      return latest;
+    }
+
     abort() {
       if (this._source.readyState !== "open") {
         throw new DOMException("MediaSource is not open.", "InvalidStateError");
       }
+      // Reset parser input even between append operations: the next append
+      // may start a new initialization instead of completing this element.
+      if (this._webmStream) {
+        const released = Math.min(this._accountedBytes, this._webmStream.pendingSize);
+        this._webmStream.reset();
+        this._accountedBytes -= released;
+        appended -= released;
+      }
       if (!this._updating) return;
       this._operation += 1;
       this._updating = false;
@@ -683,7 +748,13 @@ export function createMediaSourceScope({ origin, schedule, DOMException, onAppen
       }
       for (const buffer of this._buffers) {
         if (error) buffer._pipe.fail(new Error(error));
-        else buffer._pipe.finish();
+        else {
+          if (buffer._webmStream) {
+            const end = buffer._appendWebM(buffer._webmStream.finish());
+            if (end != null) { buffer._end = Math.max(buffer._end, end); buffer._hasSegmentTimeline = true; }
+          }
+          buffer._pipe.finish();
+        }
       }
       if (!Number.isFinite(this._duration)) {
         const end = Math.max(0, ...this._buffers.map((buffer) => buffer._end));