@torrent-tv/proxy 2.95.38 → 2.95.40

package/bin/cli.js

@@ -376,7 +376,10 @@ try {
     // Late-bound the same way `webRtcManager` is below: the torrent pool is
     // built inside `startProxyServer`, before `dataChannelHandler` — the
     // thing that actually owns a channel to push down — exists.
-    onSubtitleCues: (event) => dataChannelHandler?.publishSubtitleCues(event)
+    onSubtitleCues: (event) => dataChannelHandler?.publishSubtitleCues(event),
+    // Late-bound for the same reason: what the connections carry beyond the
+    // film is counted by the data-channel handler, built further down.
+    serviceShare: () => dataChannelHandler?.serviceShare?.() ?? null
   });
   app = started.app;
   actualPort = started.port;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.95.38",
+  "version": "2.95.40",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/server.js

@@ -117,6 +117,9 @@ function buildPortCandidates(startPort, maxAttempts = 51) {
 export async function startProxyServer({
   host, port, transcodeAudio, ffmpegBin, memoryBytes, segmentFormat, stateDir, onSubtitleCues, diagnostics, budgetPolicy,
   deliverySink = false,
+  // What viewers' connections carry beyond the film, per byte of film; the
+  // transport counts it and is built after this server, so it is late-bound.
+  serviceShare = () => null,
   // Where the proxy writes its own log. Its DIRECTORY is what matters here:
   // the browser's half of every session is written beside it, so the two are
   // on one durable disk and join by name.
@@ -608,6 +611,7 @@ export async function startProxyServer({
   let sourcePreparation;
   const outputParts = wireOutputs({
     indexMemory,
+    serviceShare,
     readMetadataActivity: () => containerOrchestrator.activity(),
     onViewerChanged: () => { void sourcePreparation?.refresh(); },
     sourceInputsFor: (output, index) => downloadMaps.inputsForOutput(output.file.sourceKey, output.outputKey, index),

package/services/encode/OutputOpening.js

@@ -587,13 +587,21 @@ export class OutputOpening {
         linkMbps: viewerLinkMbps,
         keys: [...this.#host.outputs.values()].map((other) => other.outputKey).concat(this.#host.segmentOutputFiles.addresses()),
         readyAt: (key) => this.#host.segmentOutputFiles.isClosed(key, timeline.indexForTime(Math.max(0, startPositionSeconds))),
-        observedPeakMbps: (candidate) => this.#host.observedPeakMbps?.(candidate) ?? null
+        observedPeakMbps: (candidate) => this.#host.observedPeakMbps?.(candidate) ?? null,
+        serviceShare: () => this.#host.serviceShare?.() ?? null
       }
     });
+    // Which picture rate the link was asked about, and where it came from
+    // (`SourceFile.pictureRate`): a track's own figure, the file minus its
+    // soundtracks, or the whole file as a bound.
+    const pictureRate = file.pictureRate;
+    const pictureRateNote = pictureRate
+      ? ` picture=${pictureRate.kbps}kbps (${pictureRate.source})`
+      : " picture rate unknown: the file's own rate is not known yet";
     if (decided.unavailable) {
       this.#host.logger.info(
         `transcode "${logName}": no output suits this viewer — ${decided.unavailable.reason} ` +
-        `${JSON.stringify(decided.unavailable.figures)} (wanted ${decided.wantedKey})`
+        `${JSON.stringify(decided.unavailable.figures)} (wanted ${decided.wantedKey})${pictureRateNote}`
       );
       const error = new Error(`No output suits this viewer: ${decided.unavailable.reason}.`);
       // Bound by the MACHINE rather than by the viewer's link, for the output a
@@ -616,7 +624,7 @@ export class OutputOpening {
     }
     if (decided.answer) {
       this.#host.logger.info(
-        `transcode "${logName}": ${decided.answer.verdict} for this viewer ${JSON.stringify(linkFiguresOf(decided.answer))}`
+        `transcode "${logName}": ${decided.answer.verdict} for this viewer ${JSON.stringify(linkFiguresOf(decided.answer))}${pictureRateNote}`
       );
     }
     const spec = decided.spec;

package/services/encode/Renditions.js

@@ -137,7 +137,8 @@ export class Renditions {
             Number.isFinite(base.file.pictureKbps) ? base.file.pictureKbps / 1000 : null,
             this.#host.observedPeakMbps?.(spec) ?? null
           ),
-          audioLoad
+          audioLoad,
+          this.#host.serviceShare?.() ?? null
         )
       )
     });
@@ -535,7 +536,8 @@ export class Renditions {
     }
     const linkMbps = this.#host.linkMbpsOf(base, consumerId);
     const audioLoad = this.viewerAudioLoadOf(base, consumerId);
-    const admits = (limit) => linkCouldCarry(linkMbps, loadOf(videoLoadOfLimit(limit), audioLoad)).admitted;
+    const serviceShare = this.#host.serviceShare?.() ?? null;
+    const admits = (limit) => linkCouldCarry(linkMbps, loadOf(videoLoadOfLimit(limit), audioLoad, serviceShare)).admitted;
     const target = direction === "down"
       ? limits.slice(at + 1).find(admits)
       : (at > 0 && admits(limits[at - 1]) ? limits[at - 1] : undefined);

package/services/encode/hwaccel.js

@@ -1682,13 +1682,15 @@ export function pickSoftwarePreset(benchmark, pixelsPerSecNeeded, cost = {}, fra
     if (encodePixelsPerSec === null) {
       continue;
     }
-    const speed = predictedRealtimeSpeed({
-      decodeModel: cost.decodeModel ?? null,
-      encodePixelsPerSec,
-      outputPixelsPerSec: pixelsPerSecNeeded,
-      source: cost.source ?? null,
-      observedDecodeCostSec: observed
-    });
+    const speed = typeof cost.speedForPreset === "function"
+      ? cost.speedForPreset([entry], frame, pixelsPerSecNeeded)
+      : predictedRealtimeSpeed({
+        decodeModel: cost.decodeModel ?? null,
+        encodePixelsPerSec,
+        outputPixelsPerSec: pixelsPerSecNeeded,
+        source: cost.source ?? null,
+        observedDecodeCostSec: observed
+      });
     if (speed !== null && speed >= bar) {
       return entry.preset;
     }
@@ -1786,12 +1788,15 @@ export function chooseSoftwareEncodeSettings(benchmark, ceiling, outputFps, cost
     if (fastest === null) {
       continue;
     }
-    const speed = predictedRealtimeSpeed({
-      decodeModel: cost.decodeModel ?? null,
-      encodePixelsPerSec: fastest,
-      outputPixelsPerSec: ladder[i].width * ladder[i].height * fps,
-      source: cost.source ?? null
-    });
+    const outputPixelsPerSec = ladder[i].width * ladder[i].height * fps;
+    const speed = typeof cost.speedForPreset === "function"
+      ? cost.speedForPreset([benchmark.at(-1)], ladder[i], outputPixelsPerSec)
+      : predictedRealtimeSpeed({
+        decodeModel: cost.decodeModel ?? null,
+        encodePixelsPerSec: fastest,
+        outputPixelsPerSec,
+        source: cost.source ?? null
+      });
     if (speed !== null && speed >= bar) {
       chosenIndex = i;
       break;

package/services/encode/quality/EncodeCost.js

@@ -172,6 +172,21 @@ export class EncodeCost {
     );
   }
 
+  #committedMachineCostSec() {
+    let cost = 0;
+    for (const session of this.#outputs.values()) {
+      if (!processCanBeSignalled(this.#stateFor(session))) {
+        continue;
+      }
+      const measured = this.#loadOfSession(session)?.costSec;
+      if (!Number.isFinite(measured) || measured <= 0) {
+        return null;
+      }
+      cost += measured;
+    }
+    return cost;
+  }
+
   // The last refusal printed. The offer is recomputed on the path that serves
   // every playlist, init and segment, and the figures behind it move every few
   // seconds — so the line is written when the ANSWER changes, not when it is
@@ -1085,11 +1100,26 @@ export class EncodeCost {
     if (!ceiling) {
       return null;
     }
+    const concurrentCostSec = this.#committedMachineCostSec();
+    const speedForPreset = (benchmark, frame, outputPixelsPerSec) => {
+      if (concurrentCostSec === null) {
+        return null;
+      }
+      return this.#speedOnThisMachine({
+        benchmark,
+        source,
+        width: frame.width,
+        height: frame.height,
+        fps: outputPixelsPerSec / (frame.width * frame.height),
+        observedDecodeCostSec: null,
+        concurrentCostSec
+      });
+    };
     return chooseSoftwareEncodeSettings(
       this.#host().benchmark,
       { width: ceiling.w, height: ceiling.h },
       outputFps,
-      { decodeModel: this.#host().decodeModel, source, requiredSpeed }
+      { decodeModel: this.#host().decodeModel, source, requiredSpeed, speedForPreset }
     );
   }
 }

package/services/encode/quality/QualityController.js

@@ -373,7 +373,8 @@ export class QualityController {
     const report = this.#host.linkReportOf(session, consumerId);
     const load = loadOf(
       this.#host.qualityOffer.videoLoadFor(base, height, this.#host.videoEncoder?.kind ?? ""),
-      this.#host.viewerAudioLoadOf(base, consumerId)
+      this.#host.viewerAudioLoadOf(base, consumerId),
+      this.#host.serviceShare?.() ?? null
     );
     return linkCouldCarry(report?.linkMbps ?? null, load).admitted;
   }

package/services/encode/quality/link-budget.js

@@ -20,6 +20,14 @@
  *    soundtrack whose rate nothing states.
  *
  * A load is as trustworthy as its least trustworthy part.
+ *
+ * AND WHAT THE CONNECTION CARRIES BESIDES THE FILM (torrent-tv/meta#169). The
+ * same connection carries message framing, playlists, poll answers, probes and
+ * pushed cues. Their share is measured by the transport over everything this
+ * proxy has delivered (`transport/delivery-shares.js`) and added on top of the
+ * picture and the sound. It is an average proportion and not a bound, so it
+ * moves the figure without deciding the load's class; unmeasured, nothing is
+ * added and the figures say so (`serviceShare: null`).
  */
 
 import { AUDIO_TRANSCODE_KBPS, maxrateKbpsFor, nominalKbpsFor } from "../args.js";
@@ -44,7 +52,7 @@ const CLASS_ORDER = [PEAK_CLASS.KNOWN, PEAK_CLASS.ESTIMATED, PEAK_CLASS.UNKNOWN]
 
 /**
  * @typedef {{ mbps: number | null, peakClass: string }} LoadPart
- * @typedef {{ video: LoadPart | null, audio: LoadPart | null, totalMbps: number | null, peakClass: string }} Load
+ * @typedef {{ video: LoadPart | null, audio: LoadPart | null, serviceMbps: number | null, serviceShare: number | null, totalMbps: number | null, peakClass: string }} Load
  */
 
 /**
@@ -220,22 +228,29 @@ export const SOUNDTRACK_MODE_CAUSE = Object.freeze({
 });
 
 /**
- * The whole load: the parts added, and the class of the least trustworthy.
+ * The whole load: the parts added, what the connection carries besides them,
+ * and the class of the least trustworthy part.
  *
  * @param {LoadPart | null} video
  * @param {LoadPart | null} audio
+ * @param {number | null} [serviceShare] - What the connection carries beyond
+ *   the film, per byte of film, as the transport measured it; null while
+ *   nothing has been measured.
  * @returns {Load}
  */
-export function loadOf(video, audio) {
+export function loadOf(video, audio, serviceShare = null) {
   const parts = [video, audio].filter(Boolean);
   const peakClass = parts.reduce(
     (worst, one) => (CLASS_ORDER.indexOf(one.peakClass) > CLASS_ORDER.indexOf(worst) ? one.peakClass : worst),
     PEAK_CLASS.KNOWN
   );
-  const totalMbps = peakClass === PEAK_CLASS.UNKNOWN
+  const share = Number.isFinite(serviceShare) && serviceShare >= 0 ? serviceShare : null;
+  const filmMbps = peakClass === PEAK_CLASS.UNKNOWN
     ? null
     : parts.reduce((sum, one) => sum + one.mbps, 0);
-  return { video, audio, totalMbps, peakClass };
+  const serviceMbps = filmMbps === null || share === null ? null : filmMbps * share;
+  const totalMbps = filmMbps === null ? null : filmMbps + (serviceMbps ?? 0);
+  return { video, audio, serviceMbps, serviceShare: share, totalMbps, peakClass };
 }
 
 /**
@@ -335,6 +350,8 @@ export function linkAnswerFigures(answer) {
     videoClass: answer.load.video?.peakClass ?? null,
     audioMbps: answer.load.audio?.mbps ?? null,
     audioClass: answer.load.audio?.peakClass ?? null,
+    serviceMbps: answer.load.serviceMbps ?? null,
+    serviceShare: answer.load.serviceShare ?? null,
     totalMbps: answer.load.totalMbps,
     peakClass: answer.load.peakClass
   };

package/services/encode/quality/output-format.js

@@ -62,7 +62,7 @@ import { linkAnswerFigures, linkCouldCarry, linkRefusalReason, loadOf, videoLoad
  *   soundtrack this viewer receives with the picture, from it or beside it.
  * @param {(encode: object | null) => OutputSpec} params.specWith - The output
  *   with this picture format and every other part as the request made it.
- * @param {{ mode: "auto" | "manual", linkMbps: number | null, keys: Iterable<string>, readyAt: (key: string) => boolean, observedPeakMbps?: (spec: OutputSpec) => number | null }} params.serving
+ * @param {{ mode: "auto" | "manual", linkMbps: number | null, keys: Iterable<string>, readyAt: (key: string) => boolean, observedPeakMbps?: (spec: OutputSpec) => number | null, serviceShare?: () => number | null }} params.serving
  * @returns {{
  *   spec: OutputSpec | null,
  *   budget: object | null,
@@ -97,7 +97,8 @@ export function decideOutputFormat({
     loadOf(
       videoLoadOfSpec(spec, Number.isFinite(source.pictureKbps) ? source.pictureKbps / 1000 : null,
         serving.observedPeakMbps?.(spec) ?? null),
-      audioLoad
+      audioLoad,
+      serving.serviceShare?.() ?? null
     )
   );
   const given = (spec, answer, extra = {}) => ({

package/services/media/SourceFile.js

@@ -60,30 +60,58 @@ export function sourceDecodeCharacteristics(mediaInfo) {
   };
 }
 
+/** Where a picture rate was taken from, most exact first. */
+export const PICTURE_RATE_SOURCE = Object.freeze({
+  TRACK: "the picture track's own rate",
+  FILE_MINUS_AUDIO: "the file's rate minus every soundtrack's",
+  FILE_BOUND: "bounded by the whole file's rate"
+});
+
 /**
- * The source picture's average rate, derived from the file rate after removing
- * the rates stated for every embedded audio track. A missing track rate makes
- * the picture rate unknown rather than treating the whole file rate as video.
+ * The source picture's average rate, and where it came from.
  *
- * @param {{ bitrateKbps?: number | null, audioTracks?: Array<{ bitrateKbps?: number | null }> } | null} mediaInfo
- * @returns {number | null}
+ * 1. the picture track's own rate, where the container states it per track —
+ *    MP4 counts it from the sizes of its samples, Matroska carries it in the
+ *    track's statistics tags;
+ * 2. otherwise the whole file's rate minus every soundtrack's stated rate;
+ * 3. otherwise the whole file's rate. The picture is part of the file, so its
+ *    average cannot be larger: this is an upper bound, not a guess, and it
+ *    errs towards a heavier load. It is used where a soundtrack states no
+ *    average — before torrent-tv/meta#169 that made the picture unknown, and
+ *    every MP4 and Matroska file with sound was refused on a measured link.
+ *
+ * @param {{ bitrateKbps?: number | null, videoBitrateKbps?: number | null, audioTracks?: Array<{ bitrateKbps?: number | null }> } | null} mediaInfo
+ * @returns {{ kbps: number, source: string } | null} Null when not even the
+ *   file's rate is known.
  */
-export function sourcePictureBitrateKbps(mediaInfo) {
+export function sourcePictureRate(mediaInfo) {
+  const positive = (value) => Number.isFinite(Number(value)) && Number(value) > 0;
+  if (positive(mediaInfo?.videoBitrateKbps)) {
+    return { kbps: Math.round(Number(mediaInfo.videoBitrateKbps)), source: PICTURE_RATE_SOURCE.TRACK };
+  }
   const totalKbps = Number(mediaInfo?.bitrateKbps);
-  const audioTracks = mediaInfo?.audioTracks;
-  if (!(Number.isFinite(totalKbps) && totalKbps > 0) || !Array.isArray(audioTracks)) {
+  if (!positive(totalKbps)) {
     return null;
   }
-  let audioKbps = 0;
-  for (const track of audioTracks) {
-    const rate = Number(track?.bitrateKbps);
-    if (!(Number.isFinite(rate) && rate > 0)) {
-      return null;
+  const audioTracks = Array.isArray(mediaInfo?.audioTracks) ? mediaInfo.audioTracks : null;
+  if (audioTracks && audioTracks.every((track) => positive(track?.bitrateKbps))) {
+    const pictureKbps = totalKbps - audioTracks.reduce((sum, track) => sum + Number(track.bitrateKbps), 0);
+    if (pictureKbps > 0) {
+      return { kbps: Math.round(pictureKbps), source: PICTURE_RATE_SOURCE.FILE_MINUS_AUDIO };
     }
-    audioKbps += rate;
   }
-  const pictureKbps = totalKbps - audioKbps;
-  return Number.isFinite(pictureKbps) && pictureKbps > 0 ? Math.round(pictureKbps) : null;
+  return { kbps: Math.round(totalKbps), source: PICTURE_RATE_SOURCE.FILE_BOUND };
+}
+
+/**
+ * The source picture's average rate in kbit/s, or null while not even the
+ * file's rate is known ({@link sourcePictureRate}).
+ *
+ * @param {object | null} mediaInfo
+ * @returns {number | null}
+ */
+export function sourcePictureBitrateKbps(mediaInfo) {
+  return sourcePictureRate(mediaInfo)?.kbps ?? null;
 }
 
 export class SourceFile {
@@ -221,11 +249,20 @@ export class SourceFile {
     return Number.isFinite(kbps) && kbps > 0 ? kbps / 1000 : null;
   }
 
-  /** The source picture's average rate, or null until every required fact is known. */
+  /** The source picture's average rate, or null until the file's rate is known. */
   get pictureKbps() {
     return sourcePictureBitrateKbps(this.media);
   }
 
+  /**
+   * The source picture's average rate with where it came from, for log lines.
+   *
+   * @returns {{ kbps: number, source: string } | null}
+   */
+  get pictureRate() {
+    return sourcePictureRate(this.media);
+  }
+
   /**
    * The address this proxy's own HTTP serves this file at.
    *

package/services/media/container/MatroskaContainer.js

@@ -49,7 +49,7 @@ import { RetainedReads } from "./RetainedReads.js";
 import { isUnavailable } from "./unavailable.js";
 import {
   ID_ATTACHED_FILE, ID_ATTACHMENTS, ID_CHAPTERS, ID_FILE_DATA, ID_FILE_MEDIA_TYPE, ID_FILE_NAME, ID_INFO_TITLE, ID_TAGS,
-  chapterTitlesOf, coverIndexOf, workFromTags
+  chapterTitlesOf, coverIndexOf, trackRatesFromTags, uidKeyOf, workFromTags
 } from "./matroska-work-tags.js";
 import {
   COVER_TYPES, MAX_COVER_BYTES, OutsideReadableEdges, edgeReader, emptyWorkTags, imageTypeOf, isNumberingOnly, text, textList
@@ -80,6 +80,7 @@ const ID_TRACKS = 0x1654ae6b;
 const ID_TRACK_ENTRY = 0xae;
 const ID_TRACK_NUMBER = 0xd7;
 const ID_TRACK_TYPE = 0x83;
+const ID_TRACK_UID = 0x73c5;
 const ID_FLAG_ENABLED = 0xb9;
 const ID_FLAG_DEFAULT = 0x88;
 const ID_FLAG_FORCED = 0x55aa;
@@ -531,6 +532,8 @@ export class MatroskaContainer extends Container {
     /** @type {import("../tracks/index.js").ContainerTrack[]} */
     const result = [];
     const counters = { video: -1, audio: -1, subtitle: -1 };
+    /** @type {Map<string, import("../tracks/index.js").ContainerTrack>} */
+    const byUid = new Map();
     const within = this.#readerWithin(tracksHeader.end);
     let at = tracksHeader.dataOffset;
     while (at < tracksHeader.end) {
@@ -563,15 +566,51 @@ export class MatroskaContainer extends Container {
           track.codecDelaySeconds = fields.codecDelaySeconds ?? 0;
           track.timestampScale = fields.timestampScale ?? 1;
           track.codecRanges = [[entry.dataOffset, entry.end - 1]];
+          if (fields.trackUid && (track.type === "video" || track.type === "audio")) byUid.set(fields.trackUid, track);
           result.push(track);
         }
       }
       at = entry.end;
     }
+    await this.#readTrackRates(reader, layout, byUid);
     this.#tracks = result;
     return result;
   }
 
+  /**
+   * The average rate each picture and soundtrack's statistics state, written
+   * onto the track as `bitrateKbps` (`trackRatesFromTags`).
+   *
+   * Read strictly with the track table, like the table itself: a `Tags`
+   * element whose bytes have not arrived is not an answer that the file states
+   * none, so the whole reading is asked again when they have. A `Tags`
+   * element larger than one portion is not read, and one that cannot be parsed
+   * states no rates: a damaged tag costs the rate, never the track table.
+   *
+   * @param {ElementReader} reader
+   * @param {SegmentLayout} layout
+   * @param {Map<string, import("../tracks/index.js").ContainerTrack>} byUid
+   * @returns {Promise<void>}
+   */
+  async #readTrackRates(reader, layout, byUid) {
+    if (byUid.size === 0 || layout.tagsAt === null) return;
+    const header = await reader.header(layout.tagsAt, layout.segmentEnd);
+    if (!header || header.id !== ID_TAGS || header.size === null || header.size > this.portionBytes) return;
+    const data = await reader.data(header);
+    if (!data) return;
+    let rates;
+    try {
+      rates = trackRatesFromTags(data);
+    } catch (error) {
+      if (isUnavailable(error)) throw error;
+      return;
+    }
+    for (const [uid, kbps] of rates) {
+      const track = byUid.get(uid);
+      if (track) track.bitrateKbps = kbps;
+    }
+  }
+
   /** Original-file ranges from Cues alone, without reading media block headers.
    * FFmpeg needs the declarations, the Clusters its stream search reads from the
    * first one, and the seek table as well as complete clusters.
@@ -1071,6 +1110,7 @@ function parseTrackEntry(data) {
   const fields = {
     refused: false,
     trackNumber: null,
+    trackUid: "",
     type: null,
     codecId: "",
     language: null,
@@ -1102,6 +1142,7 @@ function parseTrackEntry(data) {
       case 0x56aa: fields.codecDelaySeconds = readUint(data, f.dataOffset, f.size) / 1e9; break;
       case 0x23314f: fields.timestampScale = readFloat(data, f.dataOffset, f.size); break;
       case ID_TRACK_NUMBER: fields.trackNumber = readUint(data, f.dataOffset, f.size); break;
+      case ID_TRACK_UID: fields.trackUid = uidKeyOf(data, f); break;
       case ID_TRACK_TYPE: fields.type = readUint(data, f.dataOffset, f.size); break;
       case ID_CODEC_ID: fields.codecId = readString(data, f); break;
       case ID_CODEC_PRIVATE: fields.codecPrivateB64 = data.toString("base64", f.dataOffset, f.dataOffset + f.size); break;

package/services/media/container/Mp4Container.js

@@ -8,6 +8,7 @@
  *  - elng: extendedLanguage BCP47 (when present, replaces mdhd language per spec)
  *  - stsd: sample entry format (avc1/hev1/mp4a/tx3g/wvtt/stpp)
  *  - stbl tables for subtitle cue ranges (stts/stsz/stsc/stco/co64) and video keyframes (stss/stts/ctts/elst)
+ *  - stsz + mdhd: each track's average rate, from the sizes of its own samples
  *
  * Keyframe reading is delegated to mp4.js. The subtitle sample table is read in
  * this module, because every rule in it is a statement of ISO/IEC 14496-12 about
@@ -757,7 +758,8 @@ export class Mp4Container extends Container {
           displayWidth,
           displayHeight,
           fps: configuration?.fps ?? videoSampleRate(moov, mdhd, stbl),
-          bitDepth: configuration?.bitDepth ?? null
+          bitDepth: configuration?.bitDepth ?? null,
+          bitrateKbps: trackBitrateKbps(moov, mdhd, stbl)
         });
         if (configuration) {
           track.codecConfiguration = configuration;
@@ -811,6 +813,7 @@ export class Mp4Container extends Container {
           channels: sampleEntry?.channels ?? null,
           samplingFrequency: sampleEntry?.sampleRate ?? null,
           bitDepth: sampleEntry?.bitDepth ?? null,
+          bitrateKbps: trackBitrateKbps(moov, mdhd, stbl),
           codecDelaySeconds: sampleEntry?.codecDelaySeconds ?? 0,
           seekPrerollSeconds: sampleEntry?.seekPrerollSeconds ?? 0
         }));
@@ -854,6 +857,42 @@ export class Mp4Container extends Container {
 }
 
 /** Average decoded-frame cadence from the declared sample timing table. */
+/**
+ * The average rate of one track, from its own sample table: every sample's
+ * size (`stsz`, ISO/IEC 14496-12 §8.7.3) added up, over the track's duration
+ * in its media timescale (`mdhd`, §8.4.2). These are the bytes the track
+ * carries, counted, not a figure a muxer wrote down.
+ *
+ * Null where the table lists no samples — a fragmented file keeps them in its
+ * fragments — the duration is zero, or either box is too short for what it
+ * declares. A rate is one figure among the track's facts; a damaged table
+ * costs that figure and not the track.
+ *
+ * @param {Buffer} bytes
+ * @param {{ dataOffset: number, end: number } | null} mdhd
+ * @param {{ dataOffset: number, end: number } | null} stbl
+ * @returns {number | null} kbit/s
+ */
+function trackBitrateKbps(bytes, mdhd, stbl) {
+  const stsz = mdhd && stbl && childOf(bytes, stbl.dataOffset, stbl.end, "stsz");
+  if (!stsz) return null;
+  const version = bytes[mdhd.dataOffset];
+  const scaleAt = mdhd.dataOffset + (version === 1 ? 20 : 12);
+  if (scaleAt + (version === 1 ? 12 : 8) > mdhd.end) return null;
+  const scale = bytes.readUInt32BE(scaleAt);
+  const duration = version === 1 ? Number(bytes.readBigUInt64BE(scaleAt + 4)) : bytes.readUInt32BE(scaleAt + 4);
+  if (stsz.dataOffset + 12 > stsz.end) return null;
+  const uniform = bytes.readUInt32BE(stsz.dataOffset + 4);
+  const count = bytes.readUInt32BE(stsz.dataOffset + 8);
+  if (!uniform && stsz.dataOffset + 12 + count * 4 > stsz.end) return null;
+  let total = uniform * count;
+  if (!uniform) {
+    for (let at = stsz.dataOffset + 12, end = at + count * 4; at < end; at += 4) total += bytes.readUInt32BE(at);
+  }
+  const seconds = scale > 0 && Number.isSafeInteger(duration) ? duration / scale : 0;
+  return total > 0 && seconds > 0 ? total * 8 / seconds / 1000 : null;
+}
+
 function videoSampleRate(bytes, mdhd, stbl) {
   if (!mdhd || !stbl) return null;
   const scaleAt = mdhd.dataOffset + (bytes[mdhd.dataOffset] === 1 ? 20 : 12);

package/services/media/container/matroska-work-tags.js

@@ -25,7 +25,8 @@ export const ID_INFO_TITLE = 0x7ba9;
 const ID_TAG = 0x7373;
 const ID_TARGETS = 0x63c0;
 const ID_TARGET_TYPE_VALUE = 0x68ca;
-const TARGET_UIDS = new Set([0x63c5, 0x63c9, 0x63c4, 0x63c6]);
+const ID_TAG_TRACK_UID = 0x63c5;
+const TARGET_UIDS = new Set([ID_TAG_TRACK_UID, 0x63c9, 0x63c4, 0x63c6]);
 const ID_SIMPLE_TAG = 0x67c8;
 const ID_TAG_NAME = 0x45a3;
 const ID_TAG_STRING = 0x4487;
@@ -102,6 +103,52 @@ export function tagsByLevel(data) {
   return levels;
 }
 
+/**
+ * A Matroska UID as a key: its bytes in hexadecimal, leading zeros dropped.
+ * A UID is any 64-bit value, which a JavaScript number cannot hold exactly.
+ *
+ * @param {Buffer} buffer
+ * @param {{ dataOffset: number, size: number }} element
+ * @returns {string}
+ */
+export function uidKeyOf(buffer, element) {
+  return buffer.toString("hex", element.dataOffset, element.dataOffset + element.size).replace(/^0+/u, "");
+}
+
+/**
+ * The average rate each track's statistics state, keyed by its `TrackUID`.
+ *
+ * mkvmerge writes, per track, a `Tag` whose `Targets` name that track by
+ * `TagTrackUID` and whose `SimpleTag`s carry `BPS` — the bits the track holds
+ * over its duration — beside `NUMBER_OF_BYTES` and `DURATION`. Those are the
+ * tags read here; a track the file gives no `BPS` is left out.
+ *
+ * @param {Buffer} data - The data of a `Tags` element.
+ * @returns {Map<string, number>} kbit/s by {@link uidKeyOf} of the track.
+ */
+export function trackRatesFromTags(data) {
+  /** @type {Map<string, number>} */
+  const rates = new Map();
+  for (const tag of iterateElements(data)) {
+    if (tag.id !== ID_TAG) continue;
+    const end = Math.min(data.length, tag.dataOffset + tag.size);
+    const tracks = [];
+    for (const element of iterateElements(data, tag.dataOffset, end)) {
+      if (element.id !== ID_TARGETS) continue;
+      for (const field of iterateElements(data, element.dataOffset, Math.min(end, element.dataOffset + element.size))) {
+        if (field.id === ID_TAG_TRACK_UID) tracks.push(uidKeyOf(data, field));
+      }
+    }
+    if (tracks.length === 0) continue;
+    const found = [];
+    simpleTags(data, tag.dataOffset, end, found);
+    const bps = Number(found.find((simple) => simple.name === "BPS")?.value);
+    if (!(Number.isFinite(bps) && bps > 0)) continue;
+    for (const uid of tracks) if (uid.length > 0) rates.set(uid, bps / 1000);
+  }
+  return rates;
+}
+
 /**
  * The values one level states for one name, the default one first.
  *

package/services/media/playback-declarations.js

@@ -57,6 +57,8 @@ export function playbackDeclarations({ tracks, media, fileBytes = null }) {
     startTimeSeconds: media.startTimeSeconds,
     videoWidth: video?.width ?? 0, videoHeight: video?.height ?? 0,
     fps: video?.fps ?? null, isHdr: video?.isHdr ?? false, bitDepth: video?.bitDepth ?? null,
+    // The picture's own average, where the container states it per track.
+    videoBitrateKbps: video?.bitrateKbps ?? null,
     // The measured whole-file average prices decoding; it never addresses packets.
     bitrateKbps: Number.isFinite(media.bitrateKbps) ? media.bitrateKbps
       : Number.isSafeInteger(fileBytes) && fileBytes > 0 && media.durationSeconds > 0

package/services/media/playback-planner.js

@@ -716,6 +716,7 @@ export function createPlaybackPlanner({
           height: videoFacts.height,
           fps: videoFacts.fps,
           bitrateKbps: probe.bitrateKbps,
+          videoBitrateKbps: probe.videoBitrateKbps,
           audioTracks: probe.audioTracks,
           // Which family of the decode measurement prices this source. A video
           // that has to be re-encoded is one the browser could not play, so it
@@ -755,6 +756,7 @@ export function createPlaybackPlanner({
           width: videoFacts.width,
           height: videoFacts.height,
           bitrateKbps: probe.bitrateKbps,
+          videoBitrateKbps: probe.videoBitrateKbps,
           audioTracks: probe.audioTracks,
           fps: videoFacts.fps,
           startTime: probe.startTimeSeconds,

package/services/media/tracks/VideoTrack.js

@@ -19,6 +19,8 @@ export class VideoTrack extends ContainerTrack {
    * @param {number | null} params.fps - From container when available (otherwise from ffmpeg banner elsewhere).
    * @param {boolean} params.isHdr - From container colr / ffmpeg detection later.
    * @param {number | null} params.bitDepth
+   * @param {number | null} [params.bitrateKbps] - The rate the file states for
+   *   this track, in kbit/s: an average, not a bound.
    */
   constructor(params) {
     super({ ...params, type: "video" });
@@ -29,5 +31,6 @@ export class VideoTrack extends ContainerTrack {
     this.fps = Number.isFinite(params.fps) ? params.fps : null;
     this.isHdr = params.isHdr === true;
     this.bitDepth = Number.isFinite(params.bitDepth) ? params.bitDepth : null;
+    this.bitrateKbps = Number.isFinite(params.bitrateKbps) && params.bitrateKbps > 0 ? params.bitrateKbps : null;
   }
 }

package/services/server/wire-outputs.js

@@ -222,6 +222,10 @@ export function wireOutputs({
     encodeInputs = null,
     indexMemory = null,
     budgetPolicy = null,
+    // What viewers' connections carry beyond the film, per byte of film, as
+    // the transport measured it (`transport/delivery-shares.js`); null while
+    // nothing has been delivered.
+    serviceShare = () => null,
     onViewerChanged = null}) {
   const parts = {};
   const audioDescriptionOf = (output) => (getCachedAudioTracks?.({
@@ -363,6 +367,7 @@ export function wireOutputs({
     // re-encoded where it may be, and copied where it may not.
     get transcodeEnabled() { return parts.enabled; },
     observedPeakMbps: (spec) => parts.localObservations?.peakMbps(spec) ?? null,
+    serviceShare,
     // A viewer has been moved onto an output prepared for them: how long it
     // took, and what they held.
     notePreparation: (output, seconds, bufferedSec) =>
@@ -519,6 +524,7 @@ export function wireOutputs({
     // The largest peak an output of this mode and rate control has been seen
     // carrying here: the only figure an encoder with no bound of its own has.
     observedPeakMbps: (spec) => parts.localObservations?.peakMbps(spec) ?? null,
+    serviceShare,
     limitsFor: (frame, file) => parts.limitsFor(frame, file),
     readSourceMedia,
     get encodeInputs() { return parts.encodeInputs; },
@@ -1000,6 +1006,7 @@ export function wireOutputs({
   // otherwise.
   // The quality budget: what each output is asked to step to, and the bitrate ceiling a viewer's link sets. Everything it reads of the rest of the proxy is listed here.
   parts.quality = new QualityController({
+    serviceShare,
     // The longest an output of this mode has been seen taking to be ready for
     // a viewer moving onto it, in milliseconds, or null.
     observedPreparationMs: (output) => {

package/services/transport/data-channel-handler.js

@@ -47,6 +47,7 @@
 /** @import { DataChannel } from 'node-datachannel' */
 
 import { createDeliveryProbe, PROBE_INTERVAL_MS } from "./delivery-probe.js";
+import { DeliveryShares } from "./delivery-shares.js";
 import { Agent } from "undici";
 
 // Route availability and caller cancellation determine media request lifetime.
@@ -845,6 +846,7 @@ export function createDataChannelHandler({
       }
       try {
         channel.sendMessage(message);
+        deliveryShares.recordSent(Buffer.byteLength(message));
         sent += 1;
       } catch {
         // Closed between the lookup and the send. The subscription belongs to
@@ -862,6 +864,9 @@ export function createDataChannelHandler({
   /** Channel-scoped requests cannot be cancelled by a different connection. */
   const activeRequests = new WeakMap();
 
+  // How much of what the connections carry is not the film
+  // (`delivery-shares.js`), counted where both halves are seen.
+  const deliveryShares = new DeliveryShares();
   const { watchSendQueue, readDelivery, noteBrowserReport } = makeSendQueueWatcher({
     log: (message) => log(message),
     getTransportSnapshot,
@@ -887,7 +892,8 @@ export function createDataChannelHandler({
     readDelivery,
     getTransportSnapshot,
     witness,
-    usrsctpState
+    usrsctpState,
+    onSent: (bytes) => deliveryShares.recordSent(bytes)
   });
 
   /**
@@ -1235,6 +1241,7 @@ export function createDataChannelHandler({
         if (done) {
           chunks += body.flush();
           sendChunk(channel, requestId, null, true);
+          deliveryShares.recordBody(path, totalBytes);
           const elapsedMs = Date.now() - sendStartedAt;
           let bufferedNow = 0;
           try { bufferedNow = typeof channel.bufferedAmount === "function" ? channel.bufferedAmount() : 0; } catch { /* ignore */ }
@@ -1319,7 +1326,9 @@ export function createDataChannelHandler({
 
   function sendChunk(channel, requestId, bytes, done) {
     try {
-      channel.sendMessageBinary(encodeFrame(requestIdBytes(requestId), bytes, done));
+      const frame = encodeFrame(requestIdBytes(requestId), bytes, done);
+      channel.sendMessageBinary(frame);
+      deliveryShares.recordSent(frame.length);
     } catch {
       // Channel closed between check and send — safe to ignore.
     }
@@ -1392,13 +1401,20 @@ export function createDataChannelHandler({
    */
   function send(channel, message) {
     try {
-      channel.sendMessage(JSON.stringify(message));
+      const text = JSON.stringify(message);
+      channel.sendMessage(text);
+      deliveryShares.recordSent(Buffer.byteLength(text));
     } catch {
       // Channel closed between check and send — safe to ignore.
     }
   }
 
-  return { handleChannel, publishSubtitleCues };
+  return {
+    handleChannel,
+    publishSubtitleCues,
+    /** What the film costs viewers' links beyond itself, per byte of film, or null. */
+    serviceShare: () => deliveryShares.serviceShare()
+  };
 }
 
 /**

package/services/transport/delivery-probe.js

@@ -425,7 +425,10 @@ export function createDeliveryProbe({
   readDelivery,
   getTransportSnapshot,
   witness,
-  usrsctpState
+  usrsctpState,
+  // Every probe handed to a channel, in bytes: what it costs the viewer's link
+  // is counted with everything else the connection carries.
+  onSent = () => {}
 }) {
   /** @type {Map<string, ProbeConnection>} */
   const connections = new Map();
@@ -456,6 +459,7 @@ export function createDeliveryProbe({
     for (const channel of connection.channels.keys()) {
       try {
         channel.sendMessage(message);
+        onSent(Buffer.byteLength(message));
       } catch {
         // A channel closing between the check and the send is ordinary.
       }

package/services/transport/delivery-shares.js

@@ -0,0 +1,108 @@
+/**
+ * @file How much of what this proxy hands to its viewers' connections is not
+ * the film.
+ *
+ * A viewer's link carries the picture and the soundtrack AND everything else
+ * this proxy sends down the same connection: the framing of every data-channel
+ * message, playlists, answers to progress polls, delivery probes, pushed
+ * subtitle cues, segments sent and then abandoned. A load that counts only the
+ * picture and the sound asks the link for less than it will be given
+ * (torrent-tv/meta#169).
+ *
+ * What is counted, all of it in bytes handed to a data channel, which is the
+ * level the browser's own link measurement is taken at — application bytes,
+ * without SCTP, DTLS, UDP or IP framing — and all of it at the moment it is
+ * sent, so the three counts always describe the same messages:
+ *
+ * 1. `sent` — every message handed to a channel, frame headers included;
+ * 2. `media` — the bodies of segment and init responses delivered whole;
+ * 3. `measurement` — the bodies of the link measurement and the delivery sink,
+ *    which are sent when a connection is made or on request and are not part
+ *    of watching a film.
+ *
+ * The share is `(sent - media - measurement) / media`: what the film costs
+ * the link beyond itself, per byte of film. Counted over the life of the
+ * process and across every connection, because a viewer about to open a film
+ * has no history of their own and the traffic around a film is the proxy's,
+ * not the person's.
+ */
+
+/** Which kind of response a request path asks for. */
+export const DELIVERY_KIND = Object.freeze({
+  MEDIA: "media",
+  MEASUREMENT: "measurement",
+  SERVICE: "service"
+});
+
+const MEDIA_FILE = /\/(?:segment-\d+\.[a-z0-9]+|init\.mp4)$/u;
+const MEASUREMENT_ROUTE = /^\/api\/(?:link-probe|delivery-sink)$/u;
+
+/**
+ * What a data-channel request path asks for.
+ *
+ * @param {string} path - The request path, query included or not.
+ * @returns {string} One of {@link DELIVERY_KIND}.
+ */
+export function deliveryKindOf(path) {
+  const bare = String(path ?? "").split("?")[0];
+  if (MEDIA_FILE.test(bare)) return DELIVERY_KIND.MEDIA;
+  if (MEASUREMENT_ROUTE.test(bare)) return DELIVERY_KIND.MEASUREMENT;
+  return DELIVERY_KIND.SERVICE;
+}
+
+export class DeliveryShares {
+  #sent = 0;
+  #media = 0;
+  #measurement = 0;
+
+  /**
+   * A response body handed over whole.
+   *
+   * @param {string} path
+   * @param {number} bytes
+   */
+  recordBody(path, bytes) {
+    if (!(Number.isFinite(bytes) && bytes > 0)) return;
+    const kind = deliveryKindOf(path);
+    if (kind === DELIVERY_KIND.MEDIA) this.#media += bytes;
+    else if (kind === DELIVERY_KIND.MEASUREMENT) this.#measurement += bytes;
+  }
+
+  /**
+   * One message handed to a channel, whatever it carries.
+   *
+   * @param {number} bytes
+   */
+  recordSent(bytes) {
+    if (Number.isFinite(bytes) && bytes > 0) this.#sent += bytes;
+  }
+
+  /**
+   * What the film costs the link beyond itself, per byte of film, or null
+   * while no film has been delivered.
+   *
+   * Never below zero: a body is counted once its last message has gone, so
+   * the two counts agree exactly between responses and the body's own
+   * messages are already in `sent` when it is counted.
+   *
+   * @returns {number | null}
+   */
+  serviceShare() {
+    if (this.#media <= 0) return null;
+    return Math.max(0, (this.#sent - this.#media - this.#measurement) / this.#media);
+  }
+
+  /**
+   * The counts behind the share, for a log line.
+   *
+   * @returns {{ sentBytes: number, mediaBytes: number, measurementBytes: number, serviceShare: number | null }}
+   */
+  figures() {
+    return {
+      sentBytes: this.#sent,
+      mediaBytes: this.#media,
+      measurementBytes: this.#measurement,
+      serviceShare: this.serviceShare()
+    };
+  }
+}