feat: batch video upscaling with folder upload, directory save, and result comparison (#1051)

* feat: support batch video upscaling with folder upload and directory save

- Add multi-file selection and entire folder upload (webkitdirectory)
- Support drag & drop of both files and folders via FileSystemEntry API
- Add save directory picker using File System Access API (showDirectoryPicker)
- Process videos sequentially with per-file progress and status tracking
- Add right-side result list with click-to-compare functionality
- Add per-video duration and total batch duration display
- Add retry button for failed items with error detail display
- Remove auto-play on comparison viewer load
- Fix worker error handling: handle "error" command to reject stale promises
- Fix event listener accumulation in video comparison (AbortController)
- Fix XSS risk by escaping HTML in all innerHTML injections
- Fix URL revocation timing in download to prevent large file truncation
- Extract writeToSaveDirectory and truncateName helpers to reduce duplication
- Add Usage Guide panel explaining single/multiple/folder upload options

Files changed:
  docs/upscaler/index.html  (+1110/-181)
  docs/upscaler/upscaler.js (+110)

* fix: prevent auto-play and resource consumption during upscaling

- Set preload="metadata" on preview and comparison video elements
- Explicitly pause preview video after setting src in showVideoPreview
- Remove preview video seek sync from batch processing progress callbacks
  (was causing continuous decode during upscaling, wasting GPU resources)
- Remove preview video seek sync from retry progress callback
- All videos now require manual play; no background resource usage

* fix: improve upscaled video quality with higher bitrate and codec support

- Raise base bitrate from 2.5 Mbps (25e5) to 8 Mbps (8e6) for standard and
  firefox processors, preventing quality loss when source videos have high
  bitrates (e.g. 720p @ 16.7 Mbps was producing 1440p @ 10 Mbps, smaller
  than the original file)
- Double the bitrate for mediabunny processor (X.n1 * 2) to account for the
  4x pixel increase from 2x upscaling
- Add H.264 Level 5.1 (avc1.640033) and Level 5.2 (avc1.640034) codecs to
  the fallback lists, since Level 4.0 (avc1.640028, ~24.6 Mbps) cannot
  support the higher bitrates for 1440p+ outputs
- Add latencyMode: "quality" to VideoEncoder configs for both standard and
  firefox processors, prioritizing encoding quality over latency (suitable
  for offline processing)

* feat: add video data comparison panel for original vs upscaled metrics

- Add a comparison data table below the file info bar showing 6 metrics:
  Resolution, File Size, Duration, Est. Bitrate, Pixels, Process Time
- Display per-metric change percentage with color-coded indicators:
  green (↑) for improvements, red (↓) for regressions, gray for neutral
- Estimated bitrate calculated from file size × 8 / video duration
- Table renders after both original and upscaled video metadata loads
- Auto-hide panel on reset

* fix: make video data comparison panel full-width and responsive

- Move comparison data table from inside the left column to the full-width
  area below the left/right layout, so it is no longer constrained by the
  comparison viewer column width
- Remove table-fixed colgroup and overflow-x-auto that caused horizontal
  scrolling on smaller screens
- Table now uses w-full auto-layout, displaying all 4 columns (Metric,
  Original, Upscaled, Change) without requiring horizontal scrolling

---------

Co-authored-by: rionzhao <rionzhao@tencent.com>

compiled/artplayer-plugin-ambilight.mjs

@@ -0,0 +1,104 @@
+/*!
+ * artplayer-plugin-ambilight.js v1.1.0
+ * Github: https://github.com/zhw2590582/ArtPlayer
+ * (c) 2017-2026 Harvey Zhao
+ * Released under the MIT License.
+ */
+function artplayerPluginAmbilight(option = {}) {
+  return (art) => {
+    const { $video } = art.template;
+    const { createElement, addClass, setStyles } = art.constructor.utils;
+    const { blur = "50px", opacity = 0.5, frequency = 10, duration = 0.3 } = option;
+    const $ambilight = createElement("div");
+    const gridItems = createGridItems($ambilight);
+    setupAmbilight($ambilight, $video);
+    setupGridItems(gridItems, blur, opacity, duration);
+    const updateColors = createColorUpdater($video, gridItems, frequency);
+    let animationFrameId = null;
+    function start() {
+      if (!animationFrameId) {
+        updateColors();
+      }
+    }
+    function stop() {
+      if (animationFrameId) {
+        cancelAnimationFrame(animationFrameId);
+        animationFrameId = null;
+      }
+    }
+    art.on("ready", start);
+    art.on("destroy", stop);
+    return {
+      name: "artplayerPluginAmbilight",
+      start,
+      stop
+    };
+    function createGridItems($ambilight2) {
+      $ambilight2.innerHTML = Array.from({ length: 9 }).fill("<div></div>").join("");
+      return Array.from($ambilight2.children);
+    }
+    function setupAmbilight($ambilight2, $video2) {
+      addClass($ambilight2, "artplayer-plugin-ambilight");
+      $video2.parentNode.insertBefore($ambilight2, $video2);
+      setStyles($ambilight2, {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        zIndex: 9,
+        inset: 0,
+        display: "grid",
+        gridTemplateColumns: "1fr 1fr 1fr",
+        gridTemplateRows: "1fr 1fr 1fr"
+      });
+    }
+    function setupGridItems(gridItems2, blur2, opacity2, duration2) {
+      gridItems2.forEach(($item) => {
+        setStyles($item, {
+          opacity: opacity2,
+          filter: `blur(${blur2})`,
+          transition: `background-color ${duration2}s ease`
+        });
+      });
+    }
+    function createColorUpdater($video2, gridItems2, frequency2) {
+      const canvas = createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      canvas.width = 3;
+      canvas.height = 3;
+      function getAverageColor(x, y, w, h) {
+        ctx.drawImage($video2, x, y, w, h, 0, 0, 1, 1);
+        const [r, g, b] = ctx.getImageData(0, 0, 1, 1).data;
+        return `rgb(${r}, ${g}, ${b})`;
+      }
+      let lastUpdateTime = 0;
+      return function updateColors2() {
+        const now = performance.now();
+        if (now - lastUpdateTime < 1e3 / frequency2 || !art.playing) {
+          animationFrameId = requestAnimationFrame(updateColors2);
+          return;
+        }
+        lastUpdateTime = now;
+        const w = $video2.videoWidth / 3;
+        const h = $video2.videoHeight / 3;
+        const colors = [
+          [0, 0],
+          [w, 0],
+          [2 * w, 0],
+          [0, h],
+          [w, h],
+          [2 * w, h],
+          [0, 2 * h],
+          [w, 2 * h],
+          [2 * w, 2 * h]
+        ].map(([x, y]) => getAverageColor(x, y, w, h));
+        gridItems2.forEach(($item, index) => {
+          $item.style.backgroundColor = colors[index];
+        });
+        animationFrameId = requestAnimationFrame(updateColors2);
+      };
+    }
+  };
+}
+export {
+  artplayerPluginAmbilight as default
+};