buninu-browser 0.2.2 → 0.2.4

package/lib/media/byte-pipe.js

@@ -7,7 +7,7 @@
  * on finish/fail, which is how a decoder knows its snapshot is stale.
  * `waitFor` resolves when `size` reaches the mark or the pipe is finished.
  */
-export function createBytePipe() {
+export function createBytePipe({ retainBytes = true } = {}) {
   const chunks = [];
   let size = 0;
   let generation = 0;
@@ -25,7 +25,7 @@ export function createBytePipe() {
       if (done || bytes == null) return;
       const chunk = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
       if (!chunk.byteLength) return;
-      chunks.push(chunk);
+      if (retainBytes) chunks.push(chunk);
       size += chunk.byteLength;
       generation += 1;
       wake();

package/lib/media/position-audio.js

@@ -1,5 +1,5 @@
 /** Advance a PCM decoder to an exact sample cursor, never playing discarded PCM.
- * Reopened snapshots start at sample zero, including their pending first chunk.
+ * Reopened snapshots start at their epoch's first sample, including its pending chunk.
  * The caller holds output requests until this transaction has completed.
  */
 export async function advanceAudio(getSound, seconds, { reopen, needsMore, active = () => true }) {
@@ -10,6 +10,9 @@ export async function advanceAudio(getSound, seconds, { reopen, needsMore, activ
     if (sound.position === target) return true;
     if (sound.position > target) {
       if (!await reopen()) return false;
+      // A seek before the first retained epoch cannot be satisfied by
+      // reopening that same later epoch forever.
+      if (getSound().position > target) return false;
       continue;
     }
     // This is also the first chunk of EVERY replacement decoder. Skipping it
@@ -29,6 +32,12 @@ export async function advanceAudio(getSound, seconds, { reopen, needsMore, activ
       continue;
     }
     if (!needsMore(sound)) return false;
+    if (Number.isFinite(sound.endTime) && seconds >= sound.endTime) {
+      if (!await reopen()) return false;
+      const next = getSound();
+      if (next.snapshotId === sound.snapshotId && next.openedGeneration === sound.openedGeneration) return false;
+      continue;
+    }
     const pipe = sound.pipe;
     if (pipe.error) throw pipe.error;
     // Data may already have arrived while this snapshot was being decoded.

package/lib/media/source-snapshots.js

@@ -0,0 +1,126 @@
+import { createBytePipe } from './byte-pipe.js';
+
+// MSE may replace an MP4 initialization segment while old frames are still
+// buffered. A file demuxer cannot consume that sequence as one MP4: keep each
+// initialization and its fragments together, sharing the original byte views.
+export function createSourceSnapshots(inspect) {
+  const epochs = [];
+  const pending = [];
+  let pendingSize = 0, headers = [], candidate = null, current = null;
+  let skipMedia = false, serial = 0, fragment = null, openEnded = false;
+  const join = parts => parts.length === 1 ? parts[0] : Bun.concatArrayBuffers(parts);
+  const bytesOf = parts => {
+    const bytes = join(parts);
+    return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  };
+  const same = (a, b) => a.length === b.length && a.every((byte, index) => byte === b[index]);
+  const take = count => {
+    const parts = [];
+    pendingSize -= count;
+    while (count > 0) {
+      const first = pending.shift(), length = Math.min(count, first.length);
+      parts.push(first.subarray(0, length));
+      if (length < first.length) pending.unshift(first.subarray(length));
+      count -= length;
+    }
+    return bytesOf(parts);
+  };
+  const peekHeader = () => {
+    if (pending[0].length >= Math.min(16, pendingSize)) return pending[0];
+    const header = new Uint8Array(Math.min(16, pendingSize));
+    let offset = 0;
+    for (const part of pending) {
+      const length = Math.min(part.length, header.length - offset);
+      header.set(part.subarray(0, length), offset); offset += length;
+      if (offset === header.length) break;
+    }
+    return header;
+  };
+  const activate = start => {
+    if (!candidate) return current;
+    candidate.startTime = Number.isFinite(start) ? start : 0;
+    epochs.push(candidate);
+    current = candidate;
+    candidate = null;
+    return current;
+  };
+  const accept = (type, bytes) => {
+    if (type === 'ftyp') { headers = [bytes]; return true; }
+    if (type === 'moov') {
+      if (current && same(current.header, bytes)) { headers = []; candidate = null; return false; }
+      if (candidate && same(candidate.header, bytes)) { headers = []; return false; }
+      const pipe = createBytePipe(), state = {};
+      for (const header of headers) pipe.append(header);
+      pipe.append(bytes);
+      inspect(bytes, state);
+      candidate = { id: ++serial, pipe, state, header: bytes.slice(), startTime: 0, covered: [], fragments: [], cached: null };
+      headers = [];
+      fragment = null;
+      skipMedia = false;
+      return true;
+    }
+    if (type === 'moof') {
+      const epoch = candidate ?? current;
+      if (!epoch) { headers.push(bytes); return true; }
+      const end = inspect(bytes, epoch.state), start = epoch.state.appendStart;
+      activate(start);
+      skipMedia = Number.isFinite(start) && Number.isFinite(end)
+        && current.covered.some(([from, to]) => from <= start + 0.002 && to + 0.002 >= end);
+      if (!skipMedia) {
+        if (Number.isFinite(start)) current.startTime = Math.min(current.startTime, start);
+        fragment = { start: Number.isFinite(start) ? start : current.startTime, pipe: createBytePipe() };
+        fragment.pipe.append(bytes);
+        current.fragments.push(fragment);
+        current.cached = null;
+        if (Number.isFinite(start) && Number.isFinite(end)) current.covered.push([start, end]);
+      }
+      return !skipMedia;
+    }
+    if (type === 'mdat') {
+      activate(0); // A non-fragmented MP4 has no tfdt/moof timeline.
+      if (!current) { headers.push(bytes); return true; }
+      if (!skipMedia) { (fragment?.pipe ?? current.pipe).append(bytes); current.cached = null; }
+      return !skipMedia;
+    }
+    if (candidate) candidate.pipe.append(bytes);
+    else if (current && !skipMedia) { (fragment?.pipe ?? current.pipe).append(bytes); current.cached = null; }
+    else headers.push(bytes);
+    return true;
+  };
+  return {
+    append(bytes) {
+      if (openEnded && current) { (fragment?.pipe ?? current.pipe).append(bytes); current.cached = null; return true; }
+      if (bytes.length) { pending.push(bytes); pendingSize += bytes.length; }
+      let accepted = false;
+      while (pendingSize >= 8) {
+        const header = peekHeader(), view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+        let size = view.getUint32(0), headerSize = 8;
+        const type = String.fromCharCode(...header.subarray(4, 8));
+        // A zero-sized final mdat extends to EOF, including later appends.
+        if (size === 0 && type === 'mdat') { size = pendingSize; openEnded = true; }
+        if (size === 1) {
+          if (pendingSize < 16) break;
+          const large = view.getBigUint64(8);
+          if (large > BigInt(Number.MAX_SAFE_INTEGER)) break;
+          size = Number(large); headerSize = 16;
+        }
+        if (size < headerSize || size > pendingSize) break;
+        accepted = accept(type, take(size)) || accepted;
+      }
+      return accepted || pendingSize > 0;
+    },
+    at(seconds = 0) {
+      let selected = null;
+      for (const epoch of epochs) {
+        if (epoch.startTime <= seconds + 1e-6 && (!selected || epoch.startTime >= selected.startTime)) selected = epoch;
+      }
+      selected ??= epochs[0] ?? candidate;
+      if (!selected) return { id: 0, startTime: 0, endTime: Infinity, bytes: bytesOf([...headers, ...pending]) };
+      let endTime = Infinity;
+      for (const epoch of epochs) if (epoch.startTime > selected.startTime && epoch.startTime < endTime) endTime = epoch.startTime;
+      selected.cached ??= bytesOf([selected.pipe.bytes(), ...selected.fragments.slice()
+        .sort((a, b) => a.start - b.start).map(fragment => fragment.pipe.bytes())]);
+      return { id: selected.id, startTime: selected.startTime, endTime, bytes: selected.cached };
+    },
+  };
+}

package/lib/media/video-keyframe.js

@@ -0,0 +1,42 @@
+// wasmpeg seeks to a keyframe without returning its timestamp. Locate it by
+// comparing tiny decoded probes, then rewind before delivering full frames.
+export function seekVideoKeyframe(decoder, seconds, startTime = 0) {
+  const start = Math.max(0, startTime);
+  seconds = Math.max(start, seconds);
+  const seek = time => decoder.seek(Math.max(1, time * 1000));
+  const frame = 1 / (decoder.fps || 30);
+  if (!(seconds >= start + frame)) { seek(start); return start; }
+  const probe = time => {
+    seek(time);
+    const pixels = decoder.nextFrame(32, 18);
+    if (!pixels) return null;
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < pixels.length; i += 3) hash = Math.imul(hash ^ pixels[i], 0x01000193);
+    return hash >>> 0;
+  };
+  const target = probe(seconds);
+  let keyframe = seconds;
+  if (target !== null) {
+    let distance = 10;
+    let earlier = Math.max(start, seconds - distance);
+    let previous = probe(earlier);
+    // A GOP can span more than ten seconds. Keep widening the search until
+    // it crosses the keyframe or reaches the start; otherwise the reported
+    // time moves forward while the decoder still returns that older frame.
+    while (earlier > start && previous === target) {
+      keyframe = earlier;
+      distance *= 2;
+      earlier = Math.max(start, seconds - distance);
+      previous = probe(earlier);
+    }
+    if (previous !== target) {
+      while (keyframe - earlier > frame) {
+        const middle = (earlier + keyframe) / 2;
+        if (probe(middle) === target) keyframe = middle;
+        else earlier = middle;
+      }
+    } else keyframe = earlier;
+  }
+  seek(keyframe);
+  return keyframe;
+}

package/lib/media/webm-stream.js

@@ -0,0 +1,106 @@
+/** EBML element header, without reading or scanning the element's payload. */
+export function ebmlHeader(bytes, offset = 0) {
+  const vint = (at, id = false) => {
+    if (at >= bytes.length || bytes[at] === 0) return null;
+    let length = 1, mask = 0x80;
+    while (!(bytes[at] & mask)) { length++; mask >>= 1; }
+    if (at + length > bytes.length) return null;
+    let value = id ? bytes[at] : bytes[at] & (mask - 1);
+    let unknown = !id && value === mask - 1;
+    for (let i = 1; i < length; i++) {
+      value = value * 256 + bytes[at + i];
+      unknown &&= bytes[at + i] === 0xff;
+    }
+    return { length, value, unknown };
+  };
+  const id = vint(offset, true);
+  const size = id && vint(offset + id.length);
+  if (!size || (!size.unknown && !Number.isSafeInteger(size.value))) return null;
+  return { id: id.value, length: id.length + size.length, size: size.unknown ? Infinity : size.value };
+}
+
+const SEGMENT = 0x18538067, CLUSTER = 0x1f43b675;
+// An unknown-size Cluster ends at another Segment child, never at an ID
+// which merely happens to occur inside an encoded audio/video packet.
+const LEVEL_ONE = new Set([0x1a45dfa3, SEGMENT, CLUSTER, 0x114d9b74,
+  0x1549a966, 0x1654ae6b, 0x1c53bb6b, 0x1941a469, 0x1043a770, 0x1254c367]);
+
+/** Reassembles complete WebM elements across arbitrary SourceBuffer appends.
+ * Segment headers are emitted separately; their children (especially each
+ * Cluster) remain separate so retries can be discarded without new media.
+ * Pending input is kept as views and copied only when an element completes.
+ */
+export function createWebMStream() {
+  const chunks = [];
+  let available = 0, unknown = null;
+  const peek = count => {
+    count = Math.min(count, available);
+    if (chunks[0]?.length >= count) return chunks[0].subarray(0, count);
+    const bytes = new Uint8Array(count);
+    let offset = 0;
+    for (const chunk of chunks) {
+      const n = Math.min(chunk.length, count - offset);
+      bytes.set(chunk.subarray(0, n), offset); offset += n;
+      if (offset === count) break;
+    }
+    return bytes;
+  };
+  const take = count => {
+    const bytes = peek(count);
+    available -= count;
+    for (let left = count; left > 0;) {
+      const chunk = chunks[0];
+      if (left < chunk.length) { chunks[0] = chunk.subarray(left); break; }
+      chunks.shift(); left -= chunk.length;
+    }
+    return bytes;
+  };
+  const parse = (final = false) => {
+    const result = [];
+    while (available) {
+      const header = ebmlHeader(peek(16));
+      if (!header) break;
+      if (unknown && LEVEL_ONE.has(header.id)) {
+        result.push({ closedCluster: unknown }); unknown = null; continue;
+      }
+      if (unknown) {
+        const size = header.length + header.size;
+        if (!Number.isFinite(size) || size > available) break;
+        const bytes = take(size);
+        if (header.id === 0xe7) {
+          let time = 0;
+          for (let i = header.length; i < bytes.length; i++) time = time * 256 + bytes[i];
+          unknown.time = time;
+          unknown.prefix.push(bytes);
+        } else if (header.id === 0xa3 || header.id === 0xa0) {
+          // Live streams may use one Cluster indefinitely. A complete Block
+          // is independently delimited, so expose it without waiting for the
+          // next Cluster. The writer inserts its original prefix only once.
+          result.push({ id: CLUSTER, bytes, cluster: { token: unknown, time: unknown.time, prefix: unknown.prefix } });
+          unknown.delivered = true;
+        } else if (!unknown.delivered) unknown.prefix.push(bytes);
+      } else if (header.id === SEGMENT) {
+        result.push({ id: SEGMENT, bytes: take(header.length) });
+      } else if (header.id === CLUSTER && !Number.isFinite(header.size)) {
+        unknown = { prefix: [take(header.length)], time: 0, delivered: false, accepted: false };
+      } else {
+        const size = header.length + header.size;
+        if (!Number.isFinite(size) || size > available) break;
+        result.push({ id: header.id, bytes: take(size) });
+      }
+    }
+    if (final && unknown && !available) { result.push({ closedCluster: unknown }); unknown = null; }
+    return result;
+  };
+  return {
+    append(bytes) {
+      if (bytes.length) { chunks.push(bytes); available += bytes.length; }
+      return parse();
+    },
+    finish() { return parse(true); },
+    get pendingSize() {
+      return available + (unknown && !unknown.accepted ? unknown.prefix.reduce((sum, part) => sum + part.length, 0) : 0);
+    },
+    reset() { chunks.length = 0; available = 0; unknown = null; },
+  };
+}