@torrent-tv/proxy 2.101.40 → 2.101.42

package/package.json

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

package/services/encode/fingerprint.js

@@ -128,7 +128,10 @@ export function configurationKeyOf(fingerprint, encoder) {
   return [
     ...common,
     `device=${device?.model ?? UNKNOWN}`,
-    `driver=${device?.driver ?? UNKNOWN}`
+    `driver=${device?.driver ?? UNKNOWN}`,
+    `cpu=${fingerprint?.cpu ?? UNKNOWN}`,
+    `threads=${fingerprint?.threads ?? UNKNOWN}`,
+    ...(Number.isFinite(fingerprint?.boundCores) ? [`bound=${fingerprint.boundCores}`] : [])
   ].join(";");
 }
 

package/services/media/container/PacketIndex.js

@@ -195,11 +195,12 @@ export class PacketIndex {
     const ordered = packets.ptsAscending;
     const scanFrom = ordered ? packets.firstAtOrAfter(startAt - packets.longestDuration) : 0;
     const scanTo = ordered ? packets.firstAtOrAfter(to) : packets.length;
-    for (let index = scanFrom; index < scanTo; index++) {
-      const pts = packets.ptsAt(index);
+    const consider = (index, pts = packets.ptsAt(index)) => {
       if (pts < to && (pts >= startAt ||
         ((mode === "transcode" || track.type === "audio") && pts + packets.durationAt(index) > startAt))) selected.push(index);
-    }
+    };
+    if (ordered) for (let index = scanFrom; index < scanTo; index++) consider(index);
+    else packets.forEachInTimeRange(startAt, to, consider);
     if (selected.length === 0) {
       if (track.type === "subtitle" && (track.complete || track.coveredThrough >= to)) {
         return { kind: "result", trackId, ranges: [], packets: [], from, to, decodeFrom: from };
@@ -221,7 +222,7 @@ export class PacketIndex {
         ? { kind: "terminal", reason: "video-interval-has-no-decode-start" }
         : { kind: "needs-index", trackId, from: startAt, to };
       let endsAtKeyframe = false;
-      if (mode === "copy") for (let index = 0; index < packets.length; index++) if (packets.ptsAt(index) === to && packets.keyframeAt(index)) { endsAtKeyframe = true; break; }
+      if (mode === "copy") endsAtKeyframe = packets.someAtTime(to, index => packets.keyframeAt(index));
       if (mode === "copy" && (packets.ptsAt(first) !== from ||
         (!endsAtKeyframe && (!track.complete || to < this.boundsOf(trackId).end)))) {
         return { kind: "terminal", reason: "video-copy-cut-is-not-a-keyframe" };

package/services/media/container/PacketRecords.js

@@ -16,6 +16,8 @@ const HEADER_BYTES = 56;
 
 export class PacketRecords {
   #blocks = [];
+  // Conservative time bounds for each existing storage block.
+  #timeBounds = [];
   #addresses = [];
   #used = 0;
   #length = 0;
@@ -75,6 +77,7 @@ export class PacketRecords {
     const previousBytes = this.#bytes;
     if (value === 0) {
       this.#blocks = [];
+      this.#timeBounds = [];
       this.#addresses = [];
       this.#used = 0;
       this.#bytes = 0;
@@ -85,6 +88,8 @@ export class PacketRecords {
       const at = address.readUInt32LE(addressAt % BLOCK_BYTES + 4);
       const block = this.#blocks[blockIndex];
       this.#blocks.length = blockIndex + 1;
+      this.#timeBounds.length = blockIndex + 1;
+      this.#timeBounds[blockIndex].end = value;
       this.#addresses.length = Math.ceil(value * ADDRESS_BYTES / BLOCK_BYTES);
       // The last address block back to the size its records need, as it grew.
       const lastAddresses = this.#addresses.at(-1);
@@ -121,6 +126,27 @@ export class PacketRecords {
     return low;
   }
 
+  /** Visit stored records whose presentation intervals can overlap [from, to). */
+  forEachInTimeRange(from, to, visit) {
+    for (const bounds of this.#timeBounds) {
+      if (bounds.minPts >= to || (bounds.maxPts < from && bounds.maxEnd <= from)) continue;
+      for (let index = bounds.first; index < bounds.end; index++) {
+        const pts = this.ptsAt(index);
+        if (pts < to && (pts >= from || pts + this.durationAt(index) > from)) visit(index, pts);
+      }
+    }
+  }
+
+  someAtTime(seconds, matches) {
+    for (const bounds of this.#timeBounds) {
+      if (seconds < bounds.minPts || seconds > bounds.maxPts) continue;
+      for (let index = bounds.first; index < bounds.end; index++) {
+        if (this.ptsAt(index) === seconds && matches(index)) return true;
+      }
+    }
+    return false;
+  }
+
   push(packet) {
     if (this.#disposed) throw new Error("Packet records were released.");
     if (!Number.isFinite(packet.pts) || !Array.isArray(packet.ranges) ||
@@ -161,6 +187,8 @@ export class PacketRecords {
     if (newBlock) {
       block = payloadAllocation;
       this.#blocks.push(block);
+      this.#timeBounds.push({ first: this.#length, end: this.#length, minPts: Infinity, maxPts: -Infinity,
+        maxEnd: -Infinity });
       this.#bytes += block.length;
       this.#used = 0;
     }
@@ -186,6 +214,11 @@ export class PacketRecords {
     if (packet.streamId !== undefined) block.writeUInt32LE(packet.streamId, at + bytes - 4 - (packet.decodeFromIndex !== undefined ? 4 : 0));
     if (packet.decodeFromIndex !== undefined) block.writeUInt32LE(packet.decodeFromIndex, at + bytes - 4);
     this.#used += bytes;
+    const timeBounds = this.#timeBounds.at(-1);
+    timeBounds.end = this.#length + 1;
+    timeBounds.minPts = Math.min(timeBounds.minPts, packet.pts);
+    timeBounds.maxPts = Math.max(timeBounds.maxPts, packet.pts);
+    if (Number.isFinite(packet.duration)) timeBounds.maxEnd = Math.max(timeBounds.maxEnd, packet.pts + packet.duration);
     if (this.#descentAt < 0 && packet.pts < this.#lastPts) this.#descentAt = this.#length;
     this.#lastPts = packet.pts;
     if (packet.duration > this.#longest) this.#longest = packet.duration;
@@ -258,6 +291,10 @@ export class PacketRecords {
     const [block, at] = this.#address(this.#length - 1);
     const duration = block.readDoubleLE(at + 8) + seconds;
     block.writeDoubleLE(duration, at + 8);
+    const address = this.#addresses[Math.floor((this.#length - 1) * ADDRESS_BYTES / BLOCK_BYTES)];
+    const blockIndex = address.readUInt32LE(((this.#length - 1) * ADDRESS_BYTES) % BLOCK_BYTES);
+    const bounds = this.#timeBounds[blockIndex];
+    bounds.maxEnd = Math.max(bounds.maxEnd, block.readDoubleLE(at) + duration);
     if (duration > this.#longest) this.#longest = duration;
   }
 
@@ -267,6 +304,10 @@ export class PacketRecords {
     }
     const [block, at] = this.#address(index);
     block.writeDoubleLE(seconds, at + 8);
+    const address = this.#addresses[Math.floor(index * ADDRESS_BYTES / BLOCK_BYTES)];
+    const blockIndex = address.readUInt32LE((index * ADDRESS_BYTES) % BLOCK_BYTES);
+    const bounds = this.#timeBounds[blockIndex];
+    bounds.maxEnd = Math.max(bounds.maxEnd, block.readDoubleLE(at) + seconds);
     if (seconds > this.#longest) this.#longest = seconds;
     const flags = block.readUInt32LE(at + 48);
     block.writeUInt32LE(derived ? flags | 4 : flags & ~4, at + 48);

package/services/media/container/PacketRecordsChain.js

@@ -107,6 +107,21 @@ export class PacketRecordsChain {
     return low;
   }
 
+  forEachInTimeRange(from, to, visit) {
+    for (let part = 0; part < this.#parts.length; part++) {
+      const offset = this.#offsets[part];
+      this.#parts[part].forEachInTimeRange(from, to, (index, pts) => visit(offset + index, pts));
+    }
+  }
+
+  someAtTime(seconds, matches) {
+    for (let part = 0; part < this.#parts.length; part++) {
+      const offset = this.#offsets[part];
+      if (this.#parts[part].someAtTime(seconds, index => matches(offset + index))) return true;
+    }
+    return false;
+  }
+
   /** The tables are the container's: a request's index lets go of nothing. */
   dispose() {}
   releaseUnusedCapacity() {}