nixamp 0.23.6 → 0.23.7

package/src/channels.ts

@@ -95,6 +95,12 @@ export interface ChannelInfo {
    * plain URL is read this way, and only when a policy asks for it.
    */
   teed?: boolean;
+  /**
+   * When its show ended, wall clock, while the outro plays. A channel with
+   * this set is still on the air -- the picture says the stream has ended
+   * -- and closes on its own an hour later. Absent while the show is on.
+   */
+  ended?: number;
   /**
    * A picture of it from somewhere else: the thumbnail the site offered
    * for a pasted link, the logo a catalog gave a channel. A channel with
@@ -156,6 +162,13 @@ export const GIVE_UP = 5;
 export const STALL = 30_000;
 /** How long an on-demand channel stays up with nobody watching. */
 export const IDLE = 60_000;
+/** How long a channel plays its outro after the show, before it closes. */
+export const OUTRO_MS = 60 * 60 * 1000;
+/** The encode the outro is copied through: what a channel sends on the wire. */
+const OUTRO_ENCODE: Record<"audio" | "video", string[]> = {
+  video: ["-c", "copy", "-f", "mp4", "-movflags", "frag_keyframe+empty_moov+default_base_moof"],
+  audio: ["-c", "copy", "-f", "mp3"],
+};
 /** How much of what ffmpeg said to keep, for the last line when it dies. */
 const TAIL = 2000;
 /**
@@ -241,6 +254,16 @@ export interface ChannelOptions {
   ffmpeg: string[];
   onStart?: (info: ChannelInfo) => void;
   onEnd?: (info: ChannelInfo) => void;
+  /**
+   * The outro: the clip a channel plays once its show is over, by kind,
+   * encoded as the wire wants it (see outro.ts). Null, or absent, means a
+   * show that ends closes its channel as it always did.
+   */
+  outro?: (kind: "audio" | "video") => Promise<string | null>;
+  /** How long the outro plays before the channel closes. An hour. */
+  outroMs?: number;
+  /** Said once, when a show ends and the outro begins. */
+  onOutro?: (info: ChannelInfo) => void;
   /** How long an on-demand channel outlives its last viewer. Tests shorten it. */
   idleMs?: number;
   /** Unsent bytes a listener may hold before it is dropped. Tests shrink it. */
@@ -272,6 +295,11 @@ export class Channel {
   /** Fires when a pulled source has said nothing for STALL. */
   private watchdog: ReturnType<typeof setTimeout> | null = null;
   private stall = STALL;
+  /** Whether the outro is what is playing now: the show is over. */
+  private outroOn = false;
+  private outroTimer: ReturnType<typeof setTimeout> | null = null;
+  /** How the show was dialled, so a restart after the outro is the show again. */
+  private dialed: { source: string; encode: string[]; paced: boolean; stall: number; input: string[]; audio: string; resume: PullResume } | null = null;
   private stderr = "";
   /**
    * The last few seconds, for whoever joins next.
@@ -368,6 +396,7 @@ export class Channel {
     resume: PullResume = { live: true, position: 0 },
   ): void {
     this.stall = stall;
+    if (!this.outroOn) this.dialed = { source, encode, paced, stall, input: [...input], audio, resume };
     if (this.info.kind === "video") this.fragments = new Fragments();
     const [command, ...prefix] = this.options.ffmpeg as [string, ...string[]];
     this.info.live = resume.live;
@@ -382,9 +411,12 @@ export class Channel {
       this.info.playlistAt = at;
     }
     let current = list ? (list[at] as string) : source;
+    // The last entry is the end of the show, not a way back to the first:
+    // a list that played through is over, and says so with the outro.
     this.advance = list && list.length > 1
       ? () => {
-          at = (at + 1) % list.length;
+          if (at + 1 >= list.length) return false;
+          at += 1;
           this.info.playlistAt = at;
           current = list[at] as string;
           return true;
@@ -414,7 +446,8 @@ export class Channel {
       // policy set after the channel started applies at its next restart.
       this.throughAbort?.abort();
       this.throughAbort = null;
-      const through = this.options.through?.(this.info, from, input, audio) ?? null;
+      // The outro is a file read by ffmpeg itself: a pipe cannot loop.
+      const through = this.outroOn ? null : this.options.through?.(this.info, from, input, audio) ?? null;
       this.info.teed = through !== null;
       const child = spawn(
         command,
@@ -509,7 +542,43 @@ export class Channel {
 
     this.redial = dial;
     dial();
-    this.options.onStart?.(this.info);
+    if (!this.outroOn) this.options.onStart?.(this.info);
+  }
+
+  /**
+   * The show is over: the outro, then the end. A publisher's channel is
+   * told this when the publisher goes, so whoever joins in the next hour
+   * is shown that the stream has ended rather than nothing at all. Without
+   * an outro to play it is the same as close().
+   */
+  finish(): void {
+    if (this.closing || this.outroOn) return;
+    void this.endShow();
+  }
+
+  private async endShow(): Promise<void> {
+    const kind = this.info.kind ?? "audio";
+    const old = this.child;
+    this.child = null;
+    if (this.watchdog) clearTimeout(this.watchdog);
+    this.watchdog = null;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    old?.kill("SIGKILL");
+    const clip = this.options.outro ? await this.options.outro(kind).catch(() => null) : null;
+    if (this.closing) return;
+    if (!clip) {
+      this.close();
+      return;
+    }
+    this.outroOn = true;
+    this.info.ended = Date.now();
+    this.info.error = undefined;
+    this.startOver();
+    this.options.onOutro?.(this.info);
+    this.pull(clip, OUTRO_ENCODE[kind], true, this.stall, ["-stream_loop", "-1"], "", { live: true, position: 0 });
+    this.outroTimer = setTimeout(() => this.close(), this.options.outroMs ?? OUTRO_MS);
+    this.outroTimer.unref?.();
   }
 
   /**
@@ -522,8 +591,26 @@ export class Channel {
    * strikes a dead CDN ran up an hour ago.
    */
   restart(): boolean {
+    if (this.closing) return false;
+    // Started over from the outro: the show itself, from its beginning.
+    if (this.outroOn && this.dialed) {
+      this.outroOn = false;
+      delete this.info.ended;
+      if (this.outroTimer) clearTimeout(this.outroTimer);
+      this.outroTimer = null;
+      const old = this.child;
+      this.child = null;
+      old?.kill("SIGKILL");
+      this.failures = 0;
+      this.info.error = undefined;
+      this.info.playlistAt = 0;
+      this.startOver();
+      const show = this.dialed;
+      this.pull(show.source, show.encode, show.paced, show.stall, show.input, show.audio, { ...show.resume, position: 0 });
+      return true;
+    }
     const dial = this.redial;
-    if (!dial || this.closing) return false;
+    if (!dial) return false;
     if (this.timer) clearTimeout(this.timer);
     this.timer = null;
     if (this.watchdog) clearTimeout(this.watchdog);
@@ -613,6 +700,11 @@ export class Channel {
    */
   private dropped(sent: boolean): void {
     if (this.closing || !this.redial) return;
+    // An outro that stopped is over; there is nothing after it.
+    if (this.outroOn) {
+      this.close();
+      return;
+    }
     this.child = null;
     if (this.watchdog) clearTimeout(this.watchdog);
     this.watchdog = null;
@@ -628,6 +720,15 @@ export class Channel {
     // gave nothing is skipped the same way, counted as the failure it was,
     // so a list of dead links gives up rather than cycling for ever.
     const moved = this.advance?.() ?? false;
+    // A show that ended: a film or a podcast that played to its end, a
+    // list whose last entry did. That is not a source that dropped, and it
+    // is not dialled again from the top; it is over, and the outro says
+    // so. A live feed that stopped is a feed that dropped, and is redialled.
+    const list = (this.info.playlist?.length ?? 0) > 0;
+    if (sent && !moved && (this.info.live === false || list)) {
+      void this.endShow();
+      return;
+    }
     const ended = moved && sent;
     if (ended) this.info.error = undefined;
     else this.info.redials = (this.info.redials ?? 0) + 1;
@@ -914,6 +1015,8 @@ export class Channel {
     this.watchdog = null;
     if (this.idle) clearTimeout(this.idle);
     this.idle = null;
+    if (this.outroTimer) clearTimeout(this.outroTimer);
+    this.outroTimer = null;
     const said = lastLine(this.stderr);
     if (said && !this.info.error) this.info.error = said;
     const child = this.child;

package/src/outro.ts

@@ -0,0 +1,245 @@
+/**
+ * The outro: what a channel plays once its show is over.
+ *
+ * A live that ended used to start again from the top, for ever, because a
+ * source that finished cleanly was dialled like a source that dropped. Now
+ * it plays this: five seconds of "THIS LIVE STREAM HAS ENDED" on the
+ * plate with the mark, looped for an hour, so whoever joins late is told
+ * so by the picture and not by a blank panel. Then the channel closes.
+ *
+ * Drawn here, never committed as a file, the way the app's icons are:
+ * a bitmap, a 5x7 pixel face, and ffmpeg to make a clip of it. Encoded
+ * exactly as a channel is sent on the wire (H.264 and AAC for a picture,
+ * MP3 for sound alone) so the channel can copy it through without knowing
+ * how its own source was encoded. Made once per server and kept beside the
+ * keys; a missing or stale one is drawn again.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { deflateSync } from "node:zlib";
+
+/** How long the outro plays after a show ends, before the channel closes. */
+export const OUTRO_MS = 60 * 60 * 1000;
+/** The clip's length; it loops. */
+export const OUTRO_SECONDS = 5;
+/** Bumped when the drawing changes, so an old clip on disk is drawn again. */
+export const OUTRO_VERSION = 1;
+
+export interface Rgba { r: number; g: number; b: number; a: number }
+
+const BACKGROUND: Rgba = { r: 8, g: 12, b: 9, a: 255 };
+const GREEN: Rgba = { r: 74, g: 246, b: 137, a: 255 };
+const DIM: Rgba = { r: 34, g: 122, b: 74, a: 255 };
+const MUTED: Rgba = { r: 120, g: 150, b: 130, a: 255 };
+const BARS = [0.30, 0.55, 0.85, 0.62, 1.0, 0.72, 0.45, 0.25];
+
+/** A canvas of straight RGBA bytes. */
+export class Bitmap {
+  readonly pixels: Uint8Array;
+  constructor(readonly width: number, readonly height: number) {
+    this.pixels = new Uint8Array(width * height * 4);
+  }
+  fill(color: Rgba): void {
+    for (let i = 0; i < this.pixels.length; i += 4) this.set(i, color);
+  }
+  rect(x: number, y: number, w: number, h: number, color: Rgba): void {
+    const x0 = Math.max(0, Math.round(x));
+    const y0 = Math.max(0, Math.round(y));
+    const x1 = Math.min(this.width, Math.round(x + w));
+    const y1 = Math.min(this.height, Math.round(y + h));
+    for (let py = y0; py < y1; py++) {
+      for (let px = x0; px < x1; px++) this.set((py * this.width + px) * 4, color);
+    }
+  }
+  private set(offset: number, { r, g, b, a }: Rgba): void {
+    this.pixels[offset] = r;
+    this.pixels[offset + 1] = g;
+    this.pixels[offset + 2] = b;
+    this.pixels[offset + 3] = a;
+  }
+}
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+
+function crc32(bytes: Uint8Array): number {
+  let c = 0xffffffff;
+  for (const byte of bytes) c = (CRC_TABLE[(c ^ byte) & 0xff] as number) ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+function chunk(type: string, data: Uint8Array): Buffer {
+  const head = Buffer.alloc(8);
+  head.writeUInt32BE(data.length, 0);
+  head.write(type, 4, "ascii");
+  const body = Buffer.concat([head.subarray(4), Buffer.from(data)]);
+  const tail = Buffer.alloc(4);
+  tail.writeUInt32BE(crc32(body), 0);
+  return Buffer.concat([head.subarray(0, 4), body, tail]);
+}
+
+/** Encode as a non-interlaced 8-bit RGBA PNG. */
+export function encodePng(bitmap: Bitmap): Buffer {
+  const { width, height, pixels } = bitmap;
+  const stride = width * 4;
+  const raw = Buffer.alloc((stride + 1) * height);
+  for (let y = 0; y < height; y++) {
+    raw[y * (stride + 1)] = 0;
+    Buffer.from(pixels.subarray(y * stride, (y + 1) * stride)).copy(raw, y * (stride + 1) + 1);
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  return Buffer.concat([
+    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+    chunk("IHDR", ihdr),
+    chunk("IDAT", deflateSync(raw, { level: 9 })),
+    chunk("IEND", new Uint8Array(0)),
+  ]);
+}
+
+/** A 5x7 pixel face: the letters the outro needs and nothing else. */
+const GLYPHS: Record<string, string[]> = {
+  A: [".XXX.", "X...X", "X...X", "XXXXX", "X...X", "X...X", "X...X"],
+  C: [".XXXX", "X....", "X....", "X....", "X....", "X....", ".XXXX"],
+  D: ["XXXX.", "X...X", "X...X", "X...X", "X...X", "X...X", "XXXX."],
+  E: ["XXXXX", "X....", "X....", "XXXX.", "X....", "X....", "XXXXX"],
+  H: ["X...X", "X...X", "X...X", "XXXXX", "X...X", "X...X", "X...X"],
+  I: ["XXXXX", "..X..", "..X..", "..X..", "..X..", "..X..", "XXXXX"],
+  L: ["X....", "X....", "X....", "X....", "X....", "X....", "XXXXX"],
+  M: ["X...X", "XX.XX", "X.X.X", "X.X.X", "X...X", "X...X", "X...X"],
+  N: ["X...X", "XX..X", "X.X.X", "X..XX", "X...X", "X...X", "X...X"],
+  O: [".XXX.", "X...X", "X...X", "X...X", "X...X", "X...X", ".XXX."],
+  P: ["XXXX.", "X...X", "X...X", "XXXX.", "X....", "X....", "X...."],
+  R: ["XXXX.", "X...X", "X...X", "XXXX.", "X.X..", "X..X.", "X...X"],
+  S: [".XXXX", "X....", "X....", ".XXX.", "....X", "....X", "XXXX."],
+  T: ["XXXXX", "..X..", "..X..", "..X..", "..X..", "..X..", "..X.."],
+  V: ["X...X", "X...X", "X...X", "X...X", "X...X", ".X.X.", "..X.."],
+  X: ["X...X", "X...X", ".X.X.", "..X..", ".X.X.", "X...X", "X...X"],
+  ".": [".....", ".....", ".....", ".....", ".....", "..XX.", "..XX."],
+};
+
+export function textWidth(text: string, cell: number): number {
+  return text.length * 6 * cell - cell;
+}
+
+export function drawText(bitmap: Bitmap, text: string, x: number, y: number, cell: number, color: Rgba): void {
+  let at = x;
+  for (const letter of text) {
+    const rows = GLYPHS[letter];
+    if (rows) {
+      rows.forEach((row, r) => {
+        for (let c = 0; c < row.length; c++) if (row[c] === "X") bitmap.rect(at + c * cell, y + r * cell, cell, cell, color);
+      });
+    }
+    at += 6 * cell;
+  }
+}
+
+function drawBars(bitmap: Bitmap, left: number, bottom: number, width: number, tallest: number, scale: number): void {
+  const slot = width / BARS.length;
+  const bar = slot * 0.62;
+  BARS.forEach((value, i) => {
+    const height = Math.max(2, tallest * value);
+    const x = left + i * slot + (slot - bar) / 2;
+    bitmap.rect(x, bottom - height, bar, height, GREEN);
+    const peak = Math.max(2, scale * 0.018);
+    bitmap.rect(x, bottom - height - peak * 2.4, bar, peak, DIM);
+  });
+  bitmap.rect(left, bottom, width, Math.max(2, scale * 0.028), DIM);
+}
+
+/** The picture: the mark above the words, on the plate. 1280x720. */
+export function drawOutro(width = 1280, height = 720): Bitmap {
+  const bitmap = new Bitmap(width, height);
+  bitmap.fill(BACKGROUND);
+  const mark = height * 0.3;
+  drawBars(bitmap, (width - mark) / 2, height * 0.42, mark, mark - height * 0.02, mark * 1.8);
+  const line = "THIS LIVE STREAM HAS ENDED";
+  const cell = Math.floor(Math.min((width * 0.86) / (line.length * 6), height / 40));
+  drawText(bitmap, line, (width - textWidth(line, cell)) / 2, height * 0.56, cell, GREEN);
+  const small = Math.max(2, Math.floor(cell * 0.6));
+  const site = "NIXAMP.COM";
+  drawText(bitmap, site, (width - textWidth(site, small)) / 2, height * 0.56 + cell * 7 + small * 3, small, MUTED);
+  return bitmap;
+}
+
+/** The encode a channel copies an outro through: what a channel sends on the wire. */
+export const OUTRO_ENCODE: Record<"audio" | "video", string[]> = {
+  video: ["-c", "copy", "-f", "mp4", "-movflags", "frag_keyframe+empty_moov+default_base_moof"],
+  audio: ["-c", "copy", "-f", "mp3"],
+};
+
+export interface OutroOptions {
+  ffmpeg: string[];
+  /** Where the clips are kept. */
+  dir: string;
+  onEvent?: (message: string) => void;
+}
+
+/**
+ * The clips, drawn on first use and kept. `clip(kind)` answers the path,
+ * or null when there is no ffmpeg to make one, in which case a channel
+ * that ends simply closes as it used to.
+ */
+export class Outro {
+  private made = new Map<string, Promise<string | null>>();
+
+  constructor(private readonly options: OutroOptions) {}
+
+  clip(kind: "audio" | "video"): Promise<string | null> {
+    let pending = this.made.get(kind);
+    if (!pending) {
+      pending = Promise.resolve().then(() => this.make(kind)).catch(() => null);
+      this.made.set(kind, pending);
+      // A clip that could not be made is tried again next time, not remembered.
+      void pending.then((path) => { if (path === null) this.made.delete(kind); });
+    }
+    return pending;
+  }
+
+  private make(kind: "audio" | "video"): string | null {
+    mkdirSync(this.options.dir, { recursive: true });
+    const path = join(this.options.dir, kind === "video" ? `outro-v${OUTRO_VERSION}.mp4` : `outro-v${OUTRO_VERSION}.mp3`);
+    if (existsSync(path) && statSync(path).size > 1000) return path;
+    const [command, ...prefix] = this.options.ffmpeg;
+    if (!command) return null;
+    const args: string[] = ["-hide_banner", "-loglevel", "error", "-y"];
+    if (kind === "video") {
+      const picture = join(this.options.dir, `outro-v${OUTRO_VERSION}.png`);
+      writeFileSync(picture, encodePng(drawOutro()));
+      args.push(
+        "-loop", "1", "-framerate", "30", "-i", picture,
+        "-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo",
+        "-t", String(OUTRO_SECONDS),
+        "-c:v", "libx264", "-preset", "veryfast", "-tune", "stillimage", "-pix_fmt", "yuv420p", "-r", "30", "-g", "30", "-keyint_min", "30",
+        "-c:a", "aac", "-b:a", "64k", "-shortest", "-movflags", "+faststart",
+        path,
+      );
+    } else {
+      // Two soft notes, then quiet: something to hear on a channel with no picture.
+      args.push(
+        "-f", "lavfi", "-i",
+        `aevalsrc=0.18*sin(2*PI*523.25*t)*exp(-2.5*t)+0.18*sin(2*PI*392*t)*exp(-2.5*max(t-0.7\\,0))*gte(t\\,0.7):s=44100:d=${OUTRO_SECONDS}`,
+        "-c:a", "libmp3lame", "-b:a", "128k", path,
+      );
+    }
+    const run = spawnSync(command, [...prefix, ...args], { timeout: 60_000 });
+    if (run.error || run.status !== 0 || !existsSync(path)) {
+      this.options.onEvent?.(`  the outro could not be made${run.stderr ? `: ${run.stderr.toString("utf8").trim().split("\n").pop() ?? ""}` : ""}`);
+      return null;
+    }
+    this.options.onEvent?.(`  outro drawn: ${path}`);
+    return path;
+  }
+}

package/src/rtmp-in.ts

@@ -79,10 +79,13 @@ export class RtmpListeners {
     child.on("close", () => this.done(slot, child, channel));
   }
 
-  private done(slot: RtmpSlot, child: ChildProcess, channel: { close(): void } | null): void {
+  private done(slot: RtmpSlot, child: ChildProcess, channel: { close(): void; finish?(): void } | null): void {
     if (this.running.get(slot.port) !== child) return;
     this.running.delete(slot.port);
-    channel?.close();
+    // The publisher went: the outro plays for whoever is still there, and
+    // whoever joins in the next hour, before the channel closes.
+    if (channel?.finish) channel.finish();
+    else channel?.close();
     if (!this.stopped) this.arm(slot);
   }
 

package/src/server.ts

@@ -88,6 +88,7 @@ import { Rooms } from "./rooms.ts";
 import { Trollbox, TrollboxError, fallbackHandle, roomFor } from "./trollbox.ts";
 import { MAX_BYTES as SPEECH_BYTES, Speech, SpeechError, isWav, languageOf } from "./speech.ts";
 import { Captions } from "./captions.ts";
+import { Outro } from "./outro.ts";
 import { Profiles, Voices, spokenLine, spokenVoiceFor } from "./voices.ts";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.ts";
 import {
@@ -3394,6 +3395,8 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           // A picture of it, and a line about it, where there is one.
           art: artOf(one),
           about: one.about ?? "",
+          // Over, with the outro playing: the page says so rather than "LIVE".
+          ...(one.ended ? { ended: one.ended } : {}),
         })),
         // Anything re-streamed into this server is a live stream too, and was
         // sitting in the middle of the playlist among the files -- which is
@@ -5354,8 +5357,14 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
 
   // The pictures of channels, taken once each and kept while the channel is on.
   const art = new ArtCache();
+  // What a channel plays once its show is over: drawn here, once, by the
+  // same ffmpeg that carries the channels. No ffmpeg, no outro, and a show
+  // that ends closes its channel as before.
+  const outro = new Outro({ ffmpeg: tools.ffmpeg, dir: join(stateDir(), "outro"), onEvent: (message) => console.log(message) });
   const channels = new Channels({
     ffmpeg: tools.ffmpeg,
+    ...(tools.carries ? { outro: (kind) => outro.clip(kind) } : {}),
+    onOutro: (info) => console.log(`  "${info.id}" has ended; the outro plays for an hour.`),
     onStart: (info) =>
       console.log(`  ${info.name} is publishing to "${info.id}" (${info.format} over ${info.via}).`),
     onEnd: (info) => {

package/web/dist/assets/{hls-3VKVEQE3-CqYm-w53.js → hls-3VKVEQE3-CI1U7kbP.js}

@@ -1 +1 @@
-import{t as e}from"./index-Qo7uZEAJ.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};
+import{t as e}from"./index-5H3sUGHu.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};