nixamp 0.7.37 → 0.7.38

package/dist/channels.d.ts

@@ -40,6 +40,13 @@ export declare const GIVE_UP = 5;
  * channel that is quiet for half a minute is not being quiet, it is dead.
  */
 export declare const STALL = 30000;
+/**
+ * How much of the recent stream a newcomer is handed. About six seconds of
+ * 720p television, and a couple of seconds of 192k MP3: enough to play
+ * through a hiccup, not enough to put a viewer noticeably behind the room.
+ */
+export declare const BACKLOG_VIDEO: number;
+export declare const BACKLOG_AUDIO: number;
 /** A name that can sit in a URL and be read back in a list. */
 export declare function cleanId(value: unknown, fallback?: string): string;
 export interface ChannelOptions {
@@ -70,6 +77,19 @@ export declare class Channel {
     private watchdog;
     private stall;
     private stderr;
+    /**
+     * The last few seconds, for whoever joins next.
+     *
+     * A listener handed only what comes after they arrive starts exactly on the
+     * live edge, with nothing buffered ahead: every hiccup in the source or the
+     * network is a stall, and CNN in a browser was play, wait, play, wait, for
+     * ever. A few seconds of recent fragments, written before the live bytes,
+     * is the cushion every other live player has. For a picture the backlog
+     * starts at a fragment boundary, because a fragment is the unit a decoder
+     * can begin at; for MP3 any point will do, a frame announces itself.
+     */
+    private recent;
+    private recentBytes;
     constructor(info: ChannelInfo, options: ChannelOptions, onGone: (id: string) => void);
     start(format: string): void;
     /**
@@ -128,6 +148,8 @@ export declare class Channel {
      * make sense.
      */
     private emit;
+    /** Keep this for the next arrival, and let the oldest go once it is too much. */
+    private remember;
     /** Feed the source. */
     write(chunk: Buffer): boolean;
     pump(body: Readable): Promise<void>;

package/dist/channels.js

@@ -18,7 +18,7 @@ import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { Fragments } from "./fragments.js";
+import { Fragments, isOpening } from "./fragments.js";
 /** How long to wait before dialling a dropped source again. */
 export const REDIAL = 2000;
 /** How many times in a row a source may fail without ever sending anything. */
@@ -33,6 +33,17 @@ export const GIVE_UP = 5;
 export const STALL = 30_000;
 /** How much of what ffmpeg said to keep, for the last line when it dies. */
 const TAIL = 2000;
+/**
+ * How much of the recent stream a newcomer is handed. About six seconds of
+ * 720p television, and a couple of seconds of 192k MP3: enough to play
+ * through a hiccup, not enough to put a viewer noticeably behind the room.
+ */
+export const BACKLOG_VIDEO = 4 * 1024 * 1024;
+export const BACKLOG_AUDIO = 64 * 1024;
+/** The four-letter name in a box header, or "" for something too short. */
+function boxType(box) {
+    return box.length >= 8 ? box.toString("latin1", 4, 8) : "";
+}
 /**
  * Read everything a child says on stderr, keeping only the end of it.
  *
@@ -87,6 +98,19 @@ export class Channel {
     watchdog = null;
     stall = STALL;
     stderr = "";
+    /**
+     * The last few seconds, for whoever joins next.
+     *
+     * A listener handed only what comes after they arrive starts exactly on the
+     * live edge, with nothing buffered ahead: every hiccup in the source or the
+     * network is a stall, and CNN in a browser was play, wait, play, wait, for
+     * ever. A few seconds of recent fragments, written before the live bytes,
+     * is the cushion every other live player has. For a picture the backlog
+     * starts at a fragment boundary, because a fragment is the unit a decoder
+     * can begin at; for MP3 any point will do, a frame announces itself.
+     */
+    recent = [];
+    recentBytes = 0;
     constructor(info, options, onGone) {
         this.info = info;
         this.options = options;
@@ -234,6 +258,8 @@ export class Channel {
     startOver() {
         if (this.info.kind === "video")
             this.fragments = new Fragments();
+        this.recent = [];
+        this.recentBytes = 0;
         this.hangUp();
     }
     /** Expect output within STALL, or treat the source as gone and dial again. */
@@ -304,11 +330,32 @@ export class Channel {
      */
     emit(chunk) {
         if (!this.fragments) {
+            this.remember(chunk, BACKLOG_AUDIO, false);
             this.send(chunk);
             return;
         }
-        for (const box of this.fragments.push(chunk))
+        for (const box of this.fragments.push(chunk)) {
+            if (!isOpening(boxType(box)))
+                this.remember(box, BACKLOG_VIDEO, true);
             this.send(box);
+        }
+    }
+    /** Keep this for the next arrival, and let the oldest go once it is too much. */
+    remember(piece, cap, aligned) {
+        this.recent.push(piece);
+        this.recentBytes += piece.byteLength;
+        while (this.recent.length > 0 && this.recentBytes > cap) {
+            const gone = this.recent.shift();
+            this.recentBytes -= gone.byteLength;
+        }
+        // A picture's backlog must begin at a `moof`: an `mdat` on its own is
+        // samples nobody has been told the layout of.
+        if (aligned) {
+            while (this.recent.length > 0 && boxType(this.recent[0]) !== "moof") {
+                const gone = this.recent.shift();
+                this.recentBytes -= gone.byteLength;
+            }
+        }
     }
     /** Feed the source. */
     write(chunk) {
@@ -357,6 +404,18 @@ export class Channel {
                 // Gone before it began; the detach below still tidies up.
             }
         }
+        // Then the last few seconds, so there is something to play while the
+        // live bytes catch up, rather than a picture that stalls on every hiccup.
+        if (!this.fragments || this.fragments.ready) {
+            for (const piece of this.recent) {
+                try {
+                    listener.write(piece);
+                }
+                catch {
+                    break;
+                }
+            }
+        }
         this.listeners.add(listener);
         this.info.listeners = this.listeners.size;
         return () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.7.37",
+  "version": "0.7.38",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/channels.ts

@@ -19,7 +19,7 @@ import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Readable } from "node:stream";
-import { Fragments } from "./fragments.ts";
+import { Fragments, isOpening } from "./fragments.ts";
 
 /** Somewhere for a channel's audio to go. A response, in practice. */
 export interface Listener {
@@ -66,6 +66,18 @@ export const GIVE_UP = 5;
 export const STALL = 30_000;
 /** How much of what ffmpeg said to keep, for the last line when it dies. */
 const TAIL = 2000;
+/**
+ * How much of the recent stream a newcomer is handed. About six seconds of
+ * 720p television, and a couple of seconds of 192k MP3: enough to play
+ * through a hiccup, not enough to put a viewer noticeably behind the room.
+ */
+export const BACKLOG_VIDEO = 4 * 1024 * 1024;
+export const BACKLOG_AUDIO = 64 * 1024;
+
+/** The four-letter name in a box header, or "" for something too short. */
+function boxType(box: Buffer): string {
+  return box.length >= 8 ? box.toString("latin1", 4, 8) : "";
+}
 
 /**
  * Read everything a child says on stderr, keeping only the end of it.
@@ -126,6 +138,19 @@ export class Channel {
   private watchdog: ReturnType<typeof setTimeout> | null = null;
   private stall = STALL;
   private stderr = "";
+  /**
+   * The last few seconds, for whoever joins next.
+   *
+   * A listener handed only what comes after they arrive starts exactly on the
+   * live edge, with nothing buffered ahead: every hiccup in the source or the
+   * network is a stall, and CNN in a browser was play, wait, play, wait, for
+   * ever. A few seconds of recent fragments, written before the live bytes,
+   * is the cushion every other live player has. For a picture the backlog
+   * starts at a fragment boundary, because a fragment is the unit a decoder
+   * can begin at; for MP3 any point will do, a frame announces itself.
+   */
+  private recent: Buffer[] = [];
+  private recentBytes = 0;
 
   constructor(
     readonly info: ChannelInfo,
@@ -282,6 +307,8 @@ export class Channel {
    */
   private startOver(): void {
     if (this.info.kind === "video") this.fragments = new Fragments();
+    this.recent = [];
+    this.recentBytes = 0;
     this.hangUp();
   }
 
@@ -350,10 +377,32 @@ export class Channel {
    */
   private emit(chunk: Buffer): void {
     if (!this.fragments) {
+      this.remember(chunk, BACKLOG_AUDIO, false);
       this.send(chunk);
       return;
     }
-    for (const box of this.fragments.push(chunk)) this.send(box);
+    for (const box of this.fragments.push(chunk)) {
+      if (!isOpening(boxType(box))) this.remember(box, BACKLOG_VIDEO, true);
+      this.send(box);
+    }
+  }
+
+  /** Keep this for the next arrival, and let the oldest go once it is too much. */
+  private remember(piece: Buffer, cap: number, aligned: boolean): void {
+    this.recent.push(piece);
+    this.recentBytes += piece.byteLength;
+    while (this.recent.length > 0 && this.recentBytes > cap) {
+      const gone = this.recent.shift() as Buffer;
+      this.recentBytes -= gone.byteLength;
+    }
+    // A picture's backlog must begin at a `moof`: an `mdat` on its own is
+    // samples nobody has been told the layout of.
+    if (aligned) {
+      while (this.recent.length > 0 && boxType(this.recent[0] as Buffer) !== "moof") {
+        const gone = this.recent.shift() as Buffer;
+        this.recentBytes -= gone.byteLength;
+      }
+    }
   }
 
   /** Feed the source. */
@@ -404,6 +453,17 @@ export class Channel {
         // Gone before it began; the detach below still tidies up.
       }
     }
+    // Then the last few seconds, so there is something to play while the
+    // live bytes catch up, rather than a picture that stalls on every hiccup.
+    if (!this.fragments || this.fragments.ready) {
+      for (const piece of this.recent) {
+        try {
+          listener.write(piece);
+        } catch {
+          break;
+        }
+      }
+    }
     this.listeners.add(listener);
     this.info.listeners = this.listeners.size;
     return () => {

package/web/dist/sw.js

@@ -1,5 +1,5 @@
 /* nixamp service worker — generated, do not edit */
-const CACHE = "nixamp-1789031044115";
+const CACHE = "nixamp-1789031509853";
 const PRECACHE = [
   "/",
   "/apple-touch-icon.png",