@torrent-tv/proxy 2.107.11 → 2.107.13

package/package.json

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

package/server.js

@@ -332,16 +332,20 @@ export async function startProxyServer({
   /** @type {Record<string, object[]>} */
   const calibratedModes = {};
   if (videoEncoder) {
-    calibratedModes[videoEncoder.kind] =
-      (await calibrateEncoder({ ffmpegBin, encoder: videoEncoder, logger, processorCores })).modes;
+    const selectedCalibration = await calibrateEncoder({ ffmpegBin, encoder: videoEncoder, logger, processorCores });
+    if (selectedCalibration.assessmentComplete) {
+      calibratedModes[videoEncoder.kind] = selectedCalibration.modes;
+    }
     if (videoEncoder.kind !== "software") {
-      calibratedModes.software =
-        (await calibrateEncoder({ ffmpegBin, encoder: softwareDescriptor(), logger, processorCores })).modes;
+      const softwareCalibration = await calibrateEncoder({ ffmpegBin, encoder: softwareDescriptor(), logger, processorCores });
+      if (softwareCalibration.assessmentComplete) {
+        calibratedModes.software = softwareCalibration.modes;
+      }
       // A device that passed detection's own test and then none of whose modes
       // passed the product's is not used: detection encodes a synthetic pattern
       // with arguments of its own, and it is the product's arguments a viewer
       // is served with.
-      if (calibratedModes[videoEncoder.kind].length === 0) {
+      if (Array.isArray(calibratedModes[videoEncoder.kind]) && calibratedModes[videoEncoder.kind].length === 0) {
         logger.warn(
           `calibration: ${videoEncoder.name} passed detection but none of its modes produced correct segments ` +
           "through the product's own arguments; encoding in software instead"

package/services/encode/calibration.js

@@ -190,7 +190,7 @@ async function checkModeProducesCorrectSegments({ ffmpegBin, encoder, rung, segm
  * @param {object} [params.measure] - Replaces the three readings, for a check
  *   that must not run ffmpeg: `check`, `rawFrames`, `speed`. `speed` answers a
  *   number, or `{ speed, freeShare }` as `measureEncodeSlope` does.
- * @returns {Promise<{ modes: CalibratedMode[], refused: Array<{ preset: string, reason: string }> }>}
+ * @returns {Promise<{ modes: CalibratedMode[], refused: Array<{ preset: string, reason: string }>, assessmentComplete: boolean }>}
  */
 export async function calibrateEncoder({
   ffmpegBin,
@@ -227,6 +227,11 @@ export async function calibrateEncoder({
     }
   }
   const qualified = rungs.filter((rung) => checked.get(rung)?.ok === true);
+  // A mode that failed the correctness check is a proven refusal. Otherwise,
+  // the host must produce at least one throughput reading before an empty
+  // mode list can mean that no output is sustainable. A missing/unfinished
+  // calibration input is not evidence that the host cannot encode.
+  let assessmentComplete = qualified.length === 0;
 
   /** @type {Map<string | null, SizeReading[]>} */
   const readings = new Map(qualified.map((rung) => [rung, []]));
@@ -264,6 +269,7 @@ export async function calibrateEncoder({
           activeRungs.delete(rung);
           continue;
         }
+        assessmentComplete = true;
         readings.get(rung).push({
           width: frame.width,
           height: frame.height,
@@ -319,7 +325,9 @@ export async function calibrateEncoder({
     );
   }
   log.info(
-    `calibration: ${encoder.name} ${modes.length} of ${rungs.length} mode(s) usable ` +
+    `calibration: ${encoder.name} ${assessmentComplete
+      ? `${modes.length} of ${rungs.length} mode(s) usable`
+      : "performance was not measured"} ` +
     `(${((Date.now() - startedAt) / 1000).toFixed(1)}s)` +
     (freeShares.length > 0
       ? `; other work took ${Math.round((1 - Math.max(...freeShares)) * 100)}-${Math.round((1 - Math.min(...freeShares)) * 100)}% ` +
@@ -327,7 +335,7 @@ export async function calibrateEncoder({
       : encoder.kind === "software" ? "; the machine's load during the readings was not readable, so the figures are as read" : "") +
     (refused.length > 0 ? `; not usable: ${refused.map((one) => `${one.preset} (${one.reason})`).join(", ")}` : "")
   );
-  return { modes, refused };
+  return { modes, refused, assessmentComplete };
 }
 
 /**

package/services/media/container/PacketIndex.js

@@ -228,8 +228,14 @@ export class PacketIndex {
         return { kind: "terminal", reason: "video-copy-cut-is-not-a-keyframe" };
       }
     }
-    // Coverage is established by the parser after its codec-required lookahead;
-    // packets outside the interval are inspected but are not appended to input.
+    // A transcoder needs the first audio packet at or after the cut to flush
+    // samples decoded from the packet before it. The output filter still trims
+    // that lookahead to the requested interval. Video and copied audio do not
+    // need a packet beyond the cut.
+    if (track.type === "audio" && mode === "transcode" && ordered) {
+      const trailing = packets.firstAtOrAfter(to);
+      if (trailing < packets.length) last = Math.max(last, trailing);
+    }
     if (!track.complete && track.coveredThrough < to) {
       return { kind: "needs-index", trackId, from: startAt, to };
     }