mediabunny 1.53.0 → 1.54.0

package/dist/bundles/mediabunny.cjs

@@ -24778,6 +24778,100 @@ var Mediabunny = (() => {
       assert(decoderConfig);
       return determineVideoPacketType(codec, decoderConfig, packet.data);
     }
+    /**
+     * Computes frame rate metrics for this video track, i.e. estimates the video's frame rate. Frame rate is never
+     * determined from file metadata (which is unreliable) but is always deduced directly from the actual frame
+     * timestamps.
+     */
+    async computeFrameRateMetrics(options = {}) {
+      if (!options || typeof options !== "object") {
+        throw new TypeError("options must be an object.");
+      }
+      if (options.targetPacketCount !== void 0 && (!Number.isFinite(options.targetPacketCount) || options.targetPacketCount < 0)) {
+        throw new TypeError("options.targetPacketCount must be a non-negative number.");
+      }
+      const timeResolution = await this.getTimeResolution();
+      const targetPacketCount = options.targetPacketCount ?? 256;
+      const sink = new EncodedPacketSink(this);
+      const timestamps = [];
+      let maxTimestamp = -Infinity;
+      let probedPacketCount = 0;
+      for await (const packet of sink.packets(void 0, void 0, { metadataOnly: true })) {
+        if (timestamps.length >= targetPacketCount && packet.timestamp >= maxTimestamp) {
+          break;
+        }
+        timestamps.push(packet.timestamp);
+        maxTimestamp = Math.max(maxTimestamp, packet.timestamp);
+        probedPacketCount++;
+      }
+      const ticks = new Float64Array(timestamps.length);
+      for (let i = 0; i < timestamps.length; i++) {
+        ticks[i] = Math.round(timestamps[i] * timeResolution);
+      }
+      ticks.sort();
+      let n = 1;
+      for (let i = 1; i < ticks.length; i++) {
+        if (ticks[i] !== ticks[n - 1]) {
+          ticks[n++] = ticks[i];
+        }
+      }
+      if (n < 2) {
+        return {
+          underlyingFrameRate: null,
+          bestGuessFrameRate: timeResolution,
+          minFrameRate: timeResolution,
+          maxFrameRate: timeResolution,
+          averageFrameRate: timeResolution,
+          medianFrameRate: timeResolution,
+          frameRateIsConstant: true,
+          probedPacketCount
+        };
+      }
+      const activeTicks = ticks.subarray(0, n);
+      const underlyingFrameRate = findUnderlyingFrameRate(activeTicks, timeResolution);
+      const unitRate = underlyingFrameRate ?? timeResolution;
+      const ticksPerFrame = underlyingFrameRate !== null ? timeResolution / underlyingFrameRate : null;
+      const histogram = /* @__PURE__ */ new Map();
+      let minDifference = Infinity;
+      let maxDifference = -Infinity;
+      let totalDifference = 0;
+      for (let i = 1; i < n; i++) {
+        const tickDifference = activeTicks[i] - activeTicks[i - 1];
+        const difference = ticksPerFrame !== null ? Math.max(1, Math.round(tickDifference / ticksPerFrame)) : tickDifference;
+        histogram.set(difference, (histogram.get(difference) ?? 0) + 1);
+        minDifference = Math.min(minDifference, difference);
+        maxDifference = Math.max(maxDifference, difference);
+        totalDifference += difference;
+      }
+      const differenceCount = n - 1;
+      const sortedDifferences = [...histogram.keys()].sort((a, b) => a - b);
+      const middleA = differenceCount - 1 >> 1;
+      const middleB = differenceCount >> 1;
+      let medianDifferenceA = 0;
+      let medianDifferenceB = 0;
+      let cumulativeCount = 0;
+      for (const difference of sortedDifferences) {
+        cumulativeCount += histogram.get(difference);
+        if (medianDifferenceA === 0 && cumulativeCount > middleA) {
+          medianDifferenceA = difference;
+        }
+        if (cumulativeCount > middleB) {
+          medianDifferenceB = difference;
+          break;
+        }
+      }
+      const medianFrameRate = (unitRate / medianDifferenceA + unitRate / medianDifferenceB) / 2;
+      return {
+        underlyingFrameRate,
+        bestGuessFrameRate: underlyingFrameRate !== null ? underlyingFrameRate : getBestGuessFrameRate(medianFrameRate),
+        minFrameRate: unitRate / maxDifference,
+        maxFrameRate: unitRate / minDifference,
+        averageFrameRate: unitRate * differenceCount / totalDifference,
+        medianFrameRate,
+        frameRateIsConstant: underlyingFrameRate !== null && minDifference === 1 && maxDifference === 1,
+        probedPacketCount
+      };
+    }
   };
   var InputAudioTrack = class extends InputTrack {
     /** @internal */
@@ -24995,6 +25089,183 @@ var Mediabunny = (() => {
       return 0;
     }).map((x) => x.track);
   };
+  var findUnderlyingFrameRate = (ticks, resolution) => {
+    const MAX_DENOMINATOR = 1e6;
+    const MIN_INLIER_RATIO = 0.98;
+    const DELTA_TOLERANCE = 1 + 1e-9;
+    const MAX_EFFECTIVE_FRAME_SPAN = 1e3;
+    const KNOWN_FRAME_RATES = [
+      12,
+      15,
+      20,
+      24e3 / 1001,
+      24,
+      25,
+      3e4 / 1001,
+      30,
+      48,
+      50,
+      6e4 / 1001,
+      60,
+      100,
+      12e4 / 1001,
+      120,
+      144,
+      240
+    ];
+    if (ticks.length < 2) {
+      return null;
+    }
+    const gaps = new Float64Array(ticks.length - 1);
+    for (let i = 1; i < ticks.length; i++) {
+      const gap = ticks[i] - ticks[i - 1];
+      if (!(gap > 0)) {
+        return null;
+      }
+      gaps[i - 1] = gap;
+    }
+    const sortedGaps = gaps.slice();
+    sortedGaps.sort();
+    let period = sortedGaps[Math.floor(sortedGaps.length * 0.05)];
+    for (let iteration = 0; iteration < 6; iteration++) {
+      let totalTicks2 = 0;
+      let totalFrames2 = 0;
+      for (const gap of gaps) {
+        const multiple = Math.max(1, Math.round(gap / period));
+        if (Math.abs(gap - multiple * period) >= DELTA_TOLERANCE) {
+          continue;
+        }
+        totalTicks2 += gap;
+        totalFrames2 += multiple;
+      }
+      if (totalFrames2 === 0) {
+        return null;
+      }
+      const refinedPeriod = totalTicks2 / totalFrames2;
+      if (Math.abs(refinedPeriod - period) <= 1e-12 * Math.max(1, period)) {
+        period = refinedPeriod;
+        break;
+      }
+      period = refinedPeriod;
+    }
+    let inlierCount = 0;
+    let totalTicks = 0;
+    let totalFrames = 0;
+    for (const gap of gaps) {
+      const multiple = Math.max(1, Math.round(gap / period));
+      if (Math.abs(gap - multiple * period) >= DELTA_TOLERANCE) {
+        continue;
+      }
+      inlierCount++;
+      totalTicks += gap;
+      totalFrames += multiple;
+    }
+    if (inlierCount / gaps.length < MIN_INLIER_RATIO) {
+      return null;
+    }
+    period = totalTicks / totalFrames;
+    const uncertainty = 1 / Math.min(
+      totalFrames,
+      MAX_EFFECTIVE_FRAME_SPAN
+    );
+    const periodLo = Math.max(Number.EPSILON, period - uncertainty);
+    const periodHi = period + uncertainty;
+    const fpsLo = resolution / periodHi;
+    const fpsHi = resolution / periodLo;
+    const fittedFps = resolution / period;
+    let fps = null;
+    let bestKnownError = Infinity;
+    for (const candidate of KNOWN_FRAME_RATES) {
+      if (candidate < fpsLo || candidate > fpsHi) {
+        continue;
+      }
+      const error = Math.abs(candidate / fittedFps - 1);
+      if (error < bestKnownError) {
+        fps = candidate;
+        bestKnownError = error;
+      }
+    }
+    if (fps === null) {
+      const periodFraction = simplestFractionBetween(
+        periodLo,
+        periodHi,
+        MAX_DENOMINATOR
+      );
+      const fpsFraction = simplestFractionBetween(
+        fpsLo,
+        fpsHi,
+        MAX_DENOMINATOR
+      );
+      if (fpsFraction && (!periodFraction || fpsFraction.den < periodFraction.den || fpsFraction.den === periodFraction.den && fpsFraction.num <= periodFraction.num)) {
+        fps = fpsFraction.num / fpsFraction.den;
+      } else if (periodFraction) {
+        fps = resolution * periodFraction.den / periodFraction.num;
+      } else {
+        return null;
+      }
+    }
+    const finalPeriod = resolution / fps;
+    let finalInlierCount = 0;
+    for (const gap of gaps) {
+      const multiple = Math.max(1, Math.round(gap / finalPeriod));
+      if (Math.abs(gap - multiple * finalPeriod) < DELTA_TOLERANCE) {
+        finalInlierCount++;
+      }
+    }
+    if (finalInlierCount / gaps.length < MIN_INLIER_RATIO) {
+      return null;
+    }
+    return fps;
+  };
+  var simplestFractionBetween = (lo, hi, maxDenominator) => {
+    for (let den = 1; den <= maxDenominator; den++) {
+      const num = Math.floor(lo * den) + 1;
+      if (num / den < hi) {
+        return simplifyRational({ num, den });
+      }
+    }
+    return null;
+  };
+  var getBestGuessFrameRate = (frameRate) => {
+    const SPECIAL_FRAME_RATES = [
+      24 / 1.001,
+      30 / 1.001,
+      60 / 1.001,
+      120 / 1.001
+    ];
+    const COMMON_FRAME_RATES = [
+      12,
+      15,
+      20,
+      24,
+      25,
+      30,
+      48,
+      50,
+      60,
+      100,
+      120,
+      144,
+      240
+    ];
+    const SPECIAL_TOLERANCE = 5e-4;
+    const COMMON_TOLERANCE = 0.025;
+    for (const candidate of SPECIAL_FRAME_RATES) {
+      if (Math.abs(candidate / frameRate - 1) <= SPECIAL_TOLERANCE) {
+        return candidate;
+      }
+    }
+    let best = frameRate;
+    let bestError = Infinity;
+    for (const candidate of COMMON_FRAME_RATES) {
+      const error = Math.abs(candidate / frameRate - 1);
+      if (error <= COMMON_TOLERANCE && error < bestError) {
+        best = candidate;
+        bestError = error;
+      }
+    }
+    return best;
+  };
 
   // src/input.ts
   polyfillSymbolDispose();
@@ -29209,9 +29480,16 @@ var Mediabunny = (() => {
           if (this._monotonicity === true && position !== this._lastFlushEnd) {
             throw new Error("Internal error: Monotonicity violation.");
           }
+          const isPartialView = section.start !== 0 || section.end !== chunk.data.byteLength;
+          let data;
+          if (isPartialView && isWebKit()) {
+            data = chunk.data.slice(section.start, section.end);
+          } else {
+            data = chunk.data.subarray(section.start, section.end);
+          }
           void this._streamWriter.write({
             type: "write",
-            data: chunk.data.subarray(section.start, section.end),
+            data,
             position
           }).catch((error) => {
             this._writeError ??= error;