@torrent-tv/proxy 2.105.3 → 2.105.5

package/package.json

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

package/services/media/container/AviContainer.js

@@ -497,10 +497,11 @@ export class AviContainer extends Container {
       read.set(at, bytes);
       return bytes;
     };
-    const chainAt = async start => {
+    const chainAt = async (start, firstOffset) => {
       let bytes = Buffer.alloc(0), cursor = 0, at = start, frames = 0;
       while (frames < 3 && at < stream.count && bytes.length < 32 * 1024) {
         bytes = Buffer.concat([bytes, await bytesAt(at++)]);
+        if (at === start + 1) cursor = firstOffset;
         while (bytes.length - cursor >= 7 && frames < 3) {
           if (bytes[cursor] !== 0x0b || bytes[cursor + 1] !== 0x77) return false;
           let frame;
@@ -515,14 +516,22 @@ export class AviContainer extends Container {
     };
 
     const anchor = stream.atOrBefore(interval.from);
-    let first = -1, scannedBytes = 0;
+    let first = -1, firstOffset = -1, scannedBytes = 0;
     for (let at = anchor; at >= 0 && scannedBytes < 128 * 1024; at--) {
       const bytes = await bytesAt(at);
       scannedBytes += bytes.length;
-      if (bytes.length >= 7 && bytes[0] === 0x0b && bytes[1] === 0x77 && await chainAt(at)) {
-        first = at;
-        break;
+      for (let offset = 0; offset < bytes.length; offset++) {
+        if (bytes[offset] !== 0x0b) continue;
+        if (offset + 1 < bytes.length) {
+          if (bytes[offset + 1] !== 0x77) continue;
+        } else if (at + 1 >= stream.count || (await bytesAt(at + 1))[0] !== 0x77) continue;
+        if (await chainAt(at, offset)) {
+          first = at;
+          firstOffset = offset;
+          break;
+        }
       }
+      if (first >= 0) break;
     }
     if (first < 0) throw new Error("Indexed AVI AC-3 has no complete frame chain near the requested interval.");
 
@@ -530,7 +539,9 @@ export class AviContainer extends Container {
     try {
       for (let at = first; at < stream.count; at++) {
         const bytes = await bytesAt(at);
-        if (bytes.length) elementary.push(track.trackNumber, bytes, stream.starts[at], at === first ? { pts: stream.times[first] } : {});
+        const offset = at === first ? firstOffset : 0;
+        if (bytes.length > offset) elementary.push(track.trackNumber, bytes.subarray(offset), stream.starts[at] + offset,
+          at === first ? { pts: stream.times[first] } : {});
         const input = elementary.index.inputFor({ trackId: track.trackNumber, from: interval.from, to: interval.to,
           mode: interval.modes?.[track.trackNumber] ?? "transcode" });
         if (input.kind === "result") {

package/services/server/ViewerRequests.js

@@ -147,7 +147,8 @@ export class ViewerRequests {
     const seconds = earlyWaitRemainingSeconds(totalSeconds, elapsedMs);
     if (!Number.isFinite(seconds) || seconds < 0) return null;
     this.#logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical,
-      firstRequiredSegmentsSeconds: context.activeFirstRequiredSegmentsSeconds });
+      firstRequiredSegmentsSeconds: context.activeFirstRequiredSegmentsSeconds,
+      firstRequiredStages: context.activeFirstRequiredStages });
     return { version: 1, waitId, revision: context.revision, remainingSeconds: seconds, ageMs: 0 };
   }
 
@@ -192,13 +193,19 @@ export class ViewerRequests {
     const elapsedMs = waitElapsedSince(context, waitElapsedMs);
     const measuredWorkSeconds = processing.firstRequiredSegmentsSeconds;
     const hasActiveEstimate = Number.isFinite(measuredWorkSeconds) && measuredWorkSeconds >= 0;
+    const stagesChanged = Array.isArray(processing.firstRequiredStages) &&
+      JSON.stringify(processing.firstRequiredStages) !== JSON.stringify(context.activeFirstRequiredStages);
     const activeTotalSeconds = hasActiveEstimate
       ? elapsedMs / 1000 + measuredWorkSeconds
       : context.activeTotalSeconds;
-    const activeEstimateChanged = hasActiveEstimate && activeTotalSeconds !== context.activeTotalSeconds;
+    const activeEstimateChanged = hasActiveEstimate &&
+      (activeTotalSeconds !== context.activeTotalSeconds || stagesChanged);
     if (hasActiveEstimate) {
       context.activeTotalSeconds = activeTotalSeconds;
       context.activeFirstRequiredSegmentsSeconds = measuredWorkSeconds;
+      if (Array.isArray(processing.firstRequiredStages)) {
+        context.activeFirstRequiredStages = processing.firstRequiredStages;
+      }
     }
     const changed = featuresChanged || activeEstimateChanged;
     if (sameWait && changed) context.revision += 1;
@@ -213,7 +220,8 @@ export class ViewerRequests {
     const seconds = earlyWaitRemainingSeconds(totalSeconds, elapsedMs);
     if (!Number.isFinite(seconds) || seconds < 0) return null;
     this.#logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical,
-      firstRequiredSegmentsSeconds: hasActiveEstimate ? measuredWorkSeconds : context.activeFirstRequiredSegmentsSeconds });
+      firstRequiredSegmentsSeconds: hasActiveEstimate ? measuredWorkSeconds : context.activeFirstRequiredSegmentsSeconds,
+      firstRequiredStages: context.activeFirstRequiredStages });
     return { version: 1, waitId, revision: context.revision, remainingSeconds: seconds, ageMs: 0 };
   }
 
@@ -222,11 +230,12 @@ export class ViewerRequests {
     return Number.isFinite(estimate) ? { seconds: estimate, stagesMs: null, observations: null } : estimate;
   }
 
-  #logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical, firstRequiredSegmentsSeconds }) {
+  #logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical, firstRequiredSegmentsSeconds,
+    firstRequiredStages }) {
     if (context.loggedForecastRevision === context.revision) return;
     const basis = Number.isFinite(firstRequiredSegmentsSeconds) ? "first-required" : "historical-stages";
     const estimate = basis === "first-required"
-      ? { firstRequiredSegmentsSeconds }
+      ? { firstRequiredSegmentsSeconds, ...(Array.isArray(firstRequiredStages) ? { firstRequiredStages } : {}) }
       : { stagesMs: historical?.stagesMs ?? null, observations: historical?.observations ?? null };
     logger.info(`early wait forecast ${JSON.stringify({ waitId: context.waitId, consumer: context.consumerId,
       generation: context.generation, features: context.features, elapsedMs, revision: context.revision,
@@ -1062,7 +1071,8 @@ export class ViewerRequests {
           audioOperation: audioOperation?.operation,
           videoSpeedX: videoOperation?.speed,
           audioSpeedX: audioOperation?.speed,
-          firstRequiredSegmentsSeconds: forecast.firstRequiredSegmentsSeconds
+          firstRequiredSegmentsSeconds: forecast.firstRequiredSegmentsSeconds,
+          firstRequiredStages: forecast.firstRequiredStages
         } });
       if (waitEstimate) forecast.waitEstimate = waitEstimate;
     }
@@ -1105,6 +1115,7 @@ export class ViewerRequests {
     const holding = forecast.holdingBy;
     this.#host.noteViewerWaiting?.(consumerId || session.id,
       holding?.kind === "production" ? { address: holding.track, index: holding.segment } : null);
+    delete forecast.firstRequiredStages;
     return forecast;
   }
 

package/services/viewer/playback-readiness.js

@@ -463,23 +463,28 @@ export function predictPlaybackReadiness(input = {}) {
     // Production accepts a complete held segment input. It cannot overlap its
     // own source download; reused input retains its original arrival time.
     const processing = trackState[trackIndex].curve;
-    let admittedAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
+    let runAdmissionAt = null;
+    let runOpenSeconds = 0;
+    let productionStartAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
     if (!job.produced && encodeWork > 0) {
       const run = runStarts[trackIndex];
       const live = run.spans.some(span => segment.startSeconds >= span.start && segment.startSeconds < span.end);
       if (!live && (run.admittedAt === null || sourceArrivalAt > run.admittedAt)) {
-        run.admittedAt = admittedAt;
-        admittedAt += run.openSeconds;
+        runAdmissionAt = productionStartAt;
+        run.admittedAt = runAdmissionAt;
+        runOpenSeconds = run.openSeconds;
+        productionStartAt += runOpenSeconds;
       }
     }
-    const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, admittedAt);
+    const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, productionStartAt);
     trackFinish[trackIndex] = Math.max(trackFinish[trackIndex], producedAt);
     const sourcePlanned = sourceArrivalAt > 0 && plan.finish >= sourceArrivalAt;
     productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivalAt > 0, sourceArrivalAt,
-      sourcePlanned });
+      sourcePlanned, runAdmissionAt, runOpenSeconds, productionStartAt, encodeWork });
     const deliveryAt = link.finish(sizeBits, Math.max(transferFinish, producedAt));
     transferFinish = deliveryAt;
-    completions.push({ at: deliveryAt + finiteNonNegative(track.appendSeconds), trackIndex, segment, sourceArrivalAt,
+    const appendSeconds = finiteNonNegative(track.appendSeconds);
+    completions.push({ at: deliveryAt + appendSeconds, deliveryAt, appendSeconds, trackIndex, segment, sourceArrivalAt,
       sourcePlanned });
   }
 
@@ -547,13 +552,32 @@ export function predictPlaybackReadiness(input = {}) {
         ...(stop.unavailableSource ? { unavailableSource: stop.unavailableSource } : {}) };
     }
   }
-  const firstRequiredTrackSeconds = trackState.slice(0, requiredTracks).map((state, trackIndex) => {
+  const firstRequiredStages = trackState.slice(0, requiredTracks).map((state, trackIndex) => {
     const first = state.segments.find(segment => segment.endSeconds > position);
-    if (!first) return 0;
-    if (first.ranges.every(range => contains(state.clientRanges, range.start, range.end))) return 0;
+    if (!first) return { track: state.track.id ?? trackIndex, segment: null, alreadyBuffered: true,
+      sourceArrivalSeconds: 0, runAdmissionSeconds: null, runOpenSeconds: 0, productionStartSeconds: 0,
+      productionCompleteSeconds: 0, deliveryCompleteSeconds: 0, appendSeconds: 0, completionSeconds: 0 };
+    if (first.ranges.every(range => contains(state.clientRanges, range.start, range.end))) {
+      return { track: state.track.id ?? trackIndex, segment: first.index, alreadyBuffered: true,
+        sourceArrivalSeconds: 0, runAdmissionSeconds: null, runOpenSeconds: 0, productionStartSeconds: 0,
+        productionCompleteSeconds: 0, deliveryCompleteSeconds: 0, appendSeconds: 0, completionSeconds: 0 };
+    }
     const completion = completions.find(item => item.trackIndex === trackIndex && item.segment.index === first.index);
-    return completion?.at ?? null;
+    if (!completion) return { track: state.track.id ?? trackIndex, segment: first.index, alreadyBuffered: false,
+      sourceArrivalSeconds: null, runAdmissionSeconds: null, runOpenSeconds: null, productionStartSeconds: null,
+      productionCompleteSeconds: null, deliveryCompleteSeconds: null, appendSeconds: null, completionSeconds: null };
+    const production = productions.find(item => item.trackIndex === trackIndex && item.segment.index === first.index);
+    return { track: state.track.id ?? trackIndex, segment: first.index, alreadyBuffered: false,
+      sourceArrivalSeconds: production?.sourceArrivalAt ?? 0,
+      runAdmissionSeconds: production?.runAdmissionAt ?? null,
+      runOpenSeconds: production?.runOpenSeconds ?? 0,
+      productionStartSeconds: production?.productionStartAt ?? null,
+      productionCompleteSeconds: production?.at ?? null,
+      deliveryCompleteSeconds: completion.deliveryAt,
+      appendSeconds: completion.appendSeconds,
+      completionSeconds: completion.at };
   });
+  const firstRequiredTrackSeconds = firstRequiredStages.map(stage => stage.completionSeconds);
   const firstRequiredSegmentsSeconds = firstRequiredTrackSeconds.every(Number.isFinite)
     ? Math.max(0, ...firstRequiredTrackSeconds) : null;
   const delay = Math.max(0, ...constraints);
@@ -564,6 +588,7 @@ export function predictPlaybackReadiness(input = {}) {
       Number.isFinite(delay) ? 'minimum-safe-delay' : 'service-not-advancing', preparedSegments);
   return { ...forecast, measuredAt: now, predictedStartAt: Number.isFinite(delay) ? now + delay * 1000 : null,
     firstRequiredSegmentsSeconds,
+    firstRequiredStages,
     // The piece whose `kind` — its production, or its delivery to the page —
     // comes `atSeconds` from now while the media before it lasts
     // `aheadSeconds`: the difference is the delay.