Add public-domain NASA video sample: LR vs PyTorch/FP16/INT8/INT4 4x outputs, side-by-side grid, per-frame timings and metrics

.gitattributes

@@ -1,6 +1,7 @@
 *.bin filter=lfs diff=lfs merge=lfs -text
 *.xml filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
+input/nasa_ICON_airglow_640x360_63s-66s.mp4 filter=lfs diff=lfs merge=lfs -text
 input/nasa_bald_eagle_KSC-20230425-PH-JBS02_0003.jpg filter=lfs diff=lfs merge=lfs -text
 inputs/00003.png filter=lfs diff=lfs merge=lfs -text
 samples/eagle_4x/00_input_lr_x4.png filter=lfs diff=lfs merge=lfs -text
@@ -13,3 +14,12 @@ samples/eagle_4x/openvino_int4_mixed_w4a16.jpg filter=lfs diff=lfs merge=lfs -te
 samples/eagle_4x/openvino_int4_w4a16.jpg filter=lfs diff=lfs merge=lfs -text
 samples/eagle_4x/openvino_int4_w4a8.jpg filter=lfs diff=lfs merge=lfs -text
 samples/eagle_4x/openvino_int8_w8a8.jpg filter=lfs diff=lfs merge=lfs -text
+samples/video_airglow/00_source_lr.mp4 filter=lfs diff=lfs merge=lfs -text
+samples/video_airglow/10_pytorch_fp32_4x.mp4 filter=lfs diff=lfs merge=lfs -text
+samples/video_airglow/11_openvino_fp16_4x.mp4 filter=lfs diff=lfs merge=lfs -text
+samples/video_airglow/12_openvino_int8_w8a8_4x.mp4 filter=lfs diff=lfs merge=lfs -text
+samples/video_airglow/13_openvino_int4_mixed_4x.mp4 filter=lfs diff=lfs merge=lfs -text
+samples/video_airglow/14_openvino_int4_4x.mp4 filter=lfs diff=lfs merge=lfs -text
+samples/video_airglow/20_side_by_side_1920x780.mp4 filter=lfs diff=lfs merge=lfs -text
+samples/video_airglow/21_poster_frame.jpg filter=lfs diff=lfs merge=lfs -text
+samples/video_airglow/22_poster_detail_zoom.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -102,6 +102,36 @@ Real-ESRGAN 是純卷積的深層殘差網路（23 個 RRDB，每層輸出 `x*0.
 
 ---
 
+## 1.6 影片對比（放大前 vs 各個量化版本）
+
+除了靜態圖，repo 也放了一段**公有領域**的 NASA 影片（ISS 氣輝夜景，`GSFC_20181022_ICON_m12902_Airglow`），
+用**原始 PyTorch 模型**與**所有 OpenVINO 版本**做 640×360 → 2560×1440 的 4 倍放大，逐影格記錄時間與畫質。
+
+![video poster](samples/video_airglow/21_poster_frame.jpg)
+
+城市燈光帶的 **1:1 放大**比較（最能看出量化差別：左上 bicubic、右上 PyTorch FP32、中上 FP16、
+左下 INT8、下中 INT4 混合、右下 純 INT4）：
+
+![video zoom](samples/video_airglow/22_poster_detail_zoom.jpg)
+
+| 模型 | 大小 | 45 影格總時間 | ms/影格 | 張/秒 | vs PyTorch PSNR ↑ | SSIM ↑ | 加速比 ↑ | 影片 |
+|---|---|---|---|---|---|---|---|---|
+| `pytorch_fp32`（原始） | 67.0 MB | 663.5 s | 14745 | 0.07 | 基準 | 1.0000 | 1.0× | [`10`](samples/video_airglow/10_pytorch_fp32_4x.mp4) |
+| `openvino_fp16` | 35.1 MB | 211.5 s | 4700 | 0.21 | **45.41 dB** | **0.9927** | 3.1× | [`11`](samples/video_airglow/11_openvino_fp16_4x.mp4) |
+| `openvino_int8_w8a8` | 19.5 MB | **124.8 s** | **2773** | **0.36** | 36.90 dB | 0.9284 | **5.3×** | [`12`](samples/video_airglow/12_openvino_int8_w8a8_4x.mp4) |
+| `openvino_int4_mixed_w4a16` | 15.2 MB | 214.6 s | 4769 | 0.21 | 31.31 dB | 0.9344 | 3.1× | [`13`](samples/video_airglow/13_openvino_int4_mixed_4x.mp4) |
+| `openvino_int4_w4a16` | 11.0 MB | 246.8 s | 5485 | 0.18 | 25.40 dB | 0.7894 | 2.7× | [`14`](samples/video_airglow/14_openvino_int4_4x.mp4) |
+
+* 放大前（輸入）：[`00_source_lr.mp4`](samples/video_airglow/00_source_lr.mp4)　
+  六方並排比較：[`20_side_by_side_1920x780.mp4`](samples/video_airglow/20_side_by_side_1920x780.mp4)
+* 完整說明、來源與授權、重現方式：**[`samples/video_airglow/README.md`](samples/video_airglow/README.md)**
+
+重點結論：**INT8 (W8A8) 在 CPU 上比 PyTorch FP32 快 5.3×** 且畫質僅 36.9 dB / SSIM 0.93；
+**INT4 在 CPU 上不會更快**（CPU plugin 執行時會把 4-bit 權重解壓回 FP32/FP16），
+它的優勢是模型只有 11 MB；若要在 4-bit 尺寸下兼顧畫質，請用 `int4-mixed`。
+
+---
+
 ## 2. 安裝
 
 ```bash
@@ -132,7 +162,8 @@ cv2.imwrite('output.png', sr)
 print('output:', sr.shape, 'scale:', scale)
 ```
 
-`inputs/` 內附 3 張測試圖（來自 Real-ESRGAN 官方 inputs），可直接試跑：
+`inputs/` 內附 3 張測試圖（來自 Real-ESRGAN 官方 inputs），`samples/` 內附 1 張公有領域照片與
+1 段公有領域影片（都已用所有模型跑過），可直接試跑：
 
 ```bash
 python realesrgan_ov.py -i inputs/00003.png -o results/ -m int4-mixed -t 128
@@ -241,4 +272,5 @@ PY
 * 量化：[OpenVINO NNCF](https://github.com/openvinotoolkit/nncf)
 * 本 repo 的推論程式、轉換腳本與本說明文檔為本專案新增。
 * 樣品照片：NASA Kennedy Space Center（公有領域），見 `samples/eagle_4x/README.md` 的來源與授權說明
+* 樣品影片：NASA/Goddard ICON 任務 ISS 氣輝畫面（公有領域），見 `samples/video_airglow/README.md`
 * License：Apache-2.0（見 `LICENSE`）。

input/nasa_ICON_airglow_640x360_63s-66s.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74cfe01f6dc03aa321484e0823fa70a5128c93799ae94add6bbb66f60cf89d16
+size 933609

samples/video_airglow/00_source_lr.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bf16c8a6d168ec1476301edbe927b570a9d9cfde5db46f68f89f4549252ad02
+size 405138

samples/video_airglow/10_pytorch_fp32_4x.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b171def478b0db0ef242e98823ed36c381158fd90014b3b2d8220f059aa936a
+size 787181

samples/video_airglow/11_openvino_fp16_4x.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a2b42cc77346c1a85f4253429ae28b717bd007e85db52c62cf407709d28a476
+size 779152

samples/video_airglow/12_openvino_int8_w8a8_4x.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51423cc8a28d08065102961f6ba68c8a2297e08f618561899c18b43d713369c0
+size 927349

samples/video_airglow/13_openvino_int4_mixed_4x.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb7d64813c412ffaf931b8bc03c347ecd7bfb0ce84857332e3846b8b7b84d3a3
+size 847136

samples/video_airglow/14_openvino_int4_4x.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97b5dee515699f5c5c3425118ff9121161e79c144c06867328cdabf47d0683e8
+size 1301821

samples/video_airglow/20_side_by_side_1920x780.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b11618fa15f5688d9c6bdcbcb596628dbc1c9922224aad0264c3f6e59315381d
+size 417982

samples/video_airglow/README.md

@@ -0,0 +1,78 @@
+# 影片對比：ISS 氣輝（Airglow）夜景
+
+一段**公有領域**的 NASA 影片片段，餵給「原始 PyTorch 模型」與「所有 OpenVINO 量化版本」，
+比較 **640×360 → 4 倍（2560×1440）** 的放大結果、畫質與速度。
+
+## 來源與授權
+
+| 項目 | 內容 |
+|---|---|
+| 影片 | NASA/Goddard，*The Secrets behind Earth's Multi-colored Glow*（ICON 任務，2018-10-22 攝於 ISS） |
+| NASA ID | `GSFC_20181022_ICON_m12902_Airglow` |
+| 來源頁面 | https://images.nasa.gov/details/GSFC_20181022_ICON_m12902_Airglow |
+| 原始檔 | `GSFC_20181022_ICON_m12902_Airglow~small.mp4`（640×360, 30 fps, 194 s, 35 MB） |
+| 本 repo 內的輸入 | `input/nasa_ICON_airglow_640x360_63s-66s.mp4`（1.5 s 片段，約 0.9 MB） |
+| 授權 | **公有領域（Public Domain）** — NASA 媒體一般不受版權保護 |
+
+裁切指令（已內建在 `tools/make_video_sample.py` 的說明中）：
+
+```bash
+ffmpeg -ss 63 -t 1.5 -i GSFC_20181022_ICON_m12902_Airglow~small.mp4 \
+       -an -c:v libx264 -crf 20 -pix_fmt yuv420p input/nasa_ICON_airglow_640x360_63s-66s.mp4
+```
+
+選這段的理由：銀河、星空、氣輝帶、城市燈光與 ISS 桁架結構同時入鏡，
+高頻（星星/燈點）與低頻（大面積暗部）都有，最能看出各種量化的差別。
+
+## 檔案
+
+| 檔案 | 說明 | 大小 |
+|---|---|---|
+| `00_source_lr.mp4` | **放大前**：模型輸入 640×360 @30fps（45 影格） | 0.4 MB |
+| `10_pytorch_fp32_4x.mp4` | **原始 PyTorch FP32** 4 倍放大（2560×1440） | 0.8 MB |
+| `11_openvino_fp16_4x.mp4` | OpenVINO FP16 | 0.8 MB |
+| `12_openvino_int8_w8a8_4x.mp4` | OpenVINO INT8（W8A8） | 0.9 MB |
+| `13_openvino_int4_mixed_4x.mp4` | OpenVINO INT4 混合精度（W4/W8） | 0.8 MB |
+| `14_openvino_int4_4x.mp4` | OpenVINO 純 INT4（W4A16） | 1.3 MB |
+| `20_side_by_side_1920x780.mp4` | 2×3 並排比較（bicubic / PyTorch / FP16 / INT8 / INT4 mixed / INT4），含標籤 | 0.4 MB |
+| `21_poster_frame.jpg` | 並排比較影片的第 23 影格 | 0.4 MB |
+| `22_poster_detail_zoom.jpg` | 同一段落在城市燈光帶的 **1:1 放大**比較（最能看出差別） | 0.2 MB |
+| `metrics.json` | 機讀指標（時間、PSNR、SSIM） | – |
+
+## 實測結果
+
+測試設定：tile=128 / tile_pad=16，45 影格逐frame 量測（僅計推論時間，不含編碼），
+Xeon Platinum 8559C（16 vCPU）、OpenVINO 2026.4.1。
+
+| 模型 | 模型大小 | 總時間 | ms/影格 | 張/秒 | vs PyTorch PSNR ↑ | SSIM ↑ | 加速比 ↑ |
+|---|---|---|---|---|---|---|---|
+| `pytorch_fp32`（原始） | 67.0 MB | 663.5 s | 14745 | 0.07 | 基準 | 1.0000 | 1.0× |
+| `openvino_fp16` | 35.1 MB | 211.5 s | 4700 | 0.21 | **45.41 dB** | **0.9927** | 3.1× |
+| `openvino_int8_w8a8` | 19.5 MB | **124.8 s** | **2773** | **0.36** | 36.90 dB | 0.9284 | **5.3×** |
+| `openvino_int4_mixed_w4a16` | 15.2 MB | 214.6 s | 4769 | 0.21 | 31.31 dB | 0.9344 | 3.1× |
+| `openvino_int4_w4a16` | 11.0 MB | 246.8 s | 5485 | 0.18 | 25.40 dB | 0.7894 | 2.7× |
+
+輸入吞吐量（640×360 影格）：INT8 約 0.08 MPix/s、其餘約 0.04–0.05 MPix/s。
+
+### 結論
+
+1. **INT8 (W8A8) 是這個網路最快的版本**：比原始 PyTorch FP32 快 **5.3×**，畫質仍有 36.9 dB / SSIM 0.93，
+   在夜景這種暗部多、細節密的素材上肉眼幾乎看不出差異。
+2. **FP16 品質最好**：45.4 dB / SSIM 0.993，與 PyTorch 幾乎一致，但只有 3.1× 加速。
+3. **INT4 在 CPU 上不會更快**（2.7×，還比 INT8 慢），因為 CPU plugin 會在執行時把 `u4` 權重解壓回
+   FP32/FP16 再卷積；INT4 的價值在**模型體積只有 11 MB（PyTorch 的 1/6）**，適合記憶體受限或邊緣裝置。
+4. **純 INT4 的畫質代價在動態畫面特別明顯**：星星點會消失、暗部出現色偏與色塊（見 `22_poster_detail_zoom.jpg` 右下）。
+   `int4-mixed` 把敏感層留 INT8 後，SSIM 從 0.79 拉回 0.93，是 INT4 尺寸下最實用的選擇。
+5. 這支影片的 PSNR 比靜態圖測試高（INT4 25.4 dB vs 18.0 dB），因為夜景暗部平坦、沒有大量高頻邊緣；
+   量化誤差在這種素材上比較不容易被放大。
+
+## 重現
+
+```bash
+pip install torch onnx nncf openvino opencv-python numpy
+mkdir -p weights && curl -L -o weights/RealESRGAN_x4plus.pth \
+  https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth
+python tools/make_video_sample.py            # 全部重跑（約 25 分鐘，本機 16 vCPU）
+python tools/make_video_sample.py --grid-only    # 只重做並排比較影片
+python tools/make_video_sample.py --poster-only  # 只重做 1:1 細節比較圖
+```

samples/video_airglow/metrics.json

@@ -0,0 +1,60 @@
+{
+  "clip": {
+    "source": "nasa_ICON_airglow_640x360_63s-66s.mp4",
+    "frames": 45,
+    "fps": 30,
+    "input": "640x360",
+    "output": "2560x1440",
+    "tile": 128,
+    "tile_pad": 16,
+    "seconds": [
+      "0",
+      "1.5"
+    ]
+  },
+  "results": {
+    "pytorch_fp32": {
+      "file": "10_pytorch_fp32_4x.mp4",
+      "seconds_total": 663.54,
+      "ms_per_frame": 14745.4,
+      "fps": 0.07,
+      "input_mpix_per_s": 0.02
+    },
+    "openvino_fp16": {
+      "file": "11_openvino_fp16_4x.mp4",
+      "seconds_total": 211.5,
+      "ms_per_frame": 4700.0,
+      "fps": 0.21,
+      "input_mpix_per_s": 0.05,
+      "psnr_vs_pytorch": 45.41,
+      "ssim_vs_pytorch": 0.9927
+    },
+    "openvino_int8_w8a8": {
+      "file": "12_openvino_int8_w8a8_4x.mp4",
+      "seconds_total": 124.78,
+      "ms_per_frame": 2772.9,
+      "fps": 0.36,
+      "input_mpix_per_s": 0.08,
+      "psnr_vs_pytorch": 36.9,
+      "ssim_vs_pytorch": 0.9284
+    },
+    "openvino_int4_mixed_w4a16": {
+      "file": "13_openvino_int4_mixed_4x.mp4",
+      "seconds_total": 214.59,
+      "ms_per_frame": 4768.6,
+      "fps": 0.21,
+      "input_mpix_per_s": 0.05,
+      "psnr_vs_pytorch": 31.31,
+      "ssim_vs_pytorch": 0.9344
+    },
+    "openvino_int4_w4a16": {
+      "file": "14_openvino_int4_4x.mp4",
+      "seconds_total": 246.8,
+      "ms_per_frame": 5484.5,
+      "fps": 0.18,
+      "input_mpix_per_s": 0.04,
+      "psnr_vs_pytorch": 25.4,
+      "ssim_vs_pytorch": 0.7894
+    }
+  }
+}

tools/make_video_sample.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Build the `samples/video_airglow/` gallery: one public-domain NASA clip processed by
+the original PyTorch model and by every OpenVINO variant (INT4 / INT8 / FP16).
+
+Source: NASA/Goddard "The Secrets behind Earth's Multi-colored Glow" (ICON mission),
+airglow filmed from the ISS - NASA media is public domain.
+The clip (`input/nasa_ICON_airglow_640x360_63s-66s.mp4`, 640x360) is the LOW RESOLUTION
+input; every model upscales it to 2560x1440.
+
+Per model the script writes a 4x mp4, records the wall-clock time of every frame and
+computes PSNR/SSIM against the PyTorch FP32 reference.  Frames are streamed (never all
+kept in RAM): the reference is stored JPEG-compressed and the side-by-side grid is
+assembled in a second pass by decoding the encoded videos.
+"""
+import json
+import os
+import pathlib
+import subprocess
+import sys
+import time
+
+import cv2
+import numpy as np
+
+HERE = pathlib.Path(__file__).resolve().parent
+ROOT = HERE.parent
+sys.path.insert(0, str(ROOT))
+from realesrgan_ov import RealESRGAN  # noqa: E402
+
+# The clip is cut from the NASA video asset (see samples/video_airglow/README.md):
+#   ffmpeg -ss 63 -t 3 -i GSFC_20181022_ICON_m12902_Airglow~small.mp4 -an -c:v libx264 ...
+SRC = ROOT / 'input' / 'nasa_ICON_airglow_640x360_63s-66s.mp4'
+OUT = ROOT / 'samples' / 'video_airglow'
+SS, DUR = '0', '1.5'                 # clip start (s) / duration (s)
+FPS = 30
+TILE, TILE_PAD = 128, 16
+GRID = '20_side_by_side_1920x780.mp4'
+POSTER = '21_poster_frame.jpg'
+PANELS = [('00_source_lr.mp4', 'input (LR) bicubic x4'),
+          ('10_pytorch_fp32_4x.mp4', 'PyTorch FP32'),
+          ('11_openvino_fp16_4x.mp4', 'OV FP16'),
+          ('12_openvino_int8_w8a8_4x.mp4', 'OV INT8 W8A8'),
+          ('13_openvino_int4_mixed_4x.mp4', 'OV INT4 mixed'),
+          ('14_openvino_int4_4x.mp4', 'OV INT4 (W4A16)')]
+
+
+def psnr(a, b, peak=255.0):
+    mse = np.mean((a.astype(np.float64) - b.astype(np.float64)) ** 2)
+    return 99.0 if mse == 0 else 10 * np.log10(peak ** 2 / mse)
+
+
+def ssim(a, b):
+    a = cv2.cvtColor(a, cv2.COLOR_BGR2GRAY).astype(np.float64) / 255.
+    b = cv2.cvtColor(b, cv2.COLOR_BGR2GRAY).astype(np.float64) / 255.
+    c1, c2 = 0.01 ** 2, 0.03 ** 2
+    mu_a, mu_b = cv2.GaussianBlur(a, (11, 11), 1.5), cv2.GaussianBlur(b, (11, 11), 1.5)
+    sa = cv2.GaussianBlur(a * a, (11, 11), 1.5) - mu_a ** 2
+    sb = cv2.GaussianBlur(b * b, (11, 11), 1.5) - mu_b ** 2
+    sab = cv2.GaussianBlur(a * b, (11, 11), 1.5) - mu_a * mu_b
+    return (((2 * mu_a * mu_b + c1) * (2 * sab + c2)) / ((mu_a ** 2 + mu_b ** 2 + c1) * (sa + sb + c2))).mean()
+
+
+class Writer:
+    """Raw BGR frames -> H.264 mp4 through ffmpeg."""
+
+    def __init__(self, path, size, fps=FPS, crf=26):
+        self.w, self.h = size
+        cmd = ['ffmpeg', '-hide_banner', '-loglevel', 'error', '-y', '-f', 'rawvideo', '-pix_fmt', 'bgr24',
+               '-s', f'{self.w}x{self.h}', '-r', str(fps), '-i', '-', '-c:v', 'libx264', '-crf', str(crf),
+               '-preset', 'veryfast', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', str(path)]
+        self.proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
+
+    def write(self, frame):
+        self.proc.stdin.write(np.ascontiguousarray(frame, dtype=np.uint8).tobytes())
+
+    def close(self):
+        self.proc.stdin.close()
+        self.proc.wait()
+
+
+def cut_clip():
+    OUT.mkdir(parents=True, exist_ok=True)
+    dst = OUT / '00_source_lr.mp4'
+    if not SRC.exists():
+        raise SystemExit(f'source clip not found: {SRC}')
+    subprocess.run(['ffmpeg', '-hide_banner', '-loglevel', 'error', '-y', '-ss', SS, '-t', DUR, '-i', str(SRC),
+                    '-an', '-c:v', 'libx264', '-crf', '20', '-preset', 'veryfast', '-pix_fmt', 'yuv420p',
+                    '-movflags', '+faststart', str(dst)], check=True)
+    return dst
+
+
+def build_torch_runner():
+    """Original PyTorch model behind the same API/tiling as realesrgan_ov."""
+    import torch
+    from rrdbnet_arch import RRDBNet
+    weights = os.environ.get('REALESRGAN_PTH', str(ROOT / 'weights' / 'RealESRGAN_x4plus.pth'))
+    if not os.path.exists(weights):
+        raise SystemExit(f'PyTorch checkpoint not found: {weights}\n'
+                         '  curl -L -o weights/RealESRGAN_x4plus.pth \\\n'
+                         '    https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth')
+    ckpt = torch.load(weights, map_location='cpu', weights_only=True)
+    net = RRDBNet(3, 3, 4, 64, 23, 32)
+    net.load_state_dict(ckpt['params_ema'] if 'params_ema' in ckpt else ckpt['params'], strict=True)
+    net.eval()
+
+    class Shim:  # mimics ov.CompiledModel: compiled([NCHW float32]) -> [(1, C, H, W)]
+        def __call__(self, inputs):
+            with torch.inference_mode():
+                return [net(torch.from_numpy(inputs[0])).numpy()]
+
+    runner = RealESRGAN.__new__(RealESRGAN)   # reuse _forward_tiled without compiling a model
+    runner.compiled = Shim()
+    runner.scale = 4
+    return runner
+
+
+LABEL_H = 30
+
+
+def build_zoom_poster(frame_idx=22, crop=(150, 1010, 640, 360)):
+    """2x3 poster with a 1:1 zoom on the city-lights strip of every variant."""
+    x, y, cw, ch = crop
+    colors = [(235, 235, 235), (255, 255, 255), (255, 255, 255),
+              (235, 235, 235), (235, 235, 235), (235, 235, 235)]
+    tiles = []
+    for panel in range(len(PANELS)):
+        cap = cv2.VideoCapture(str(OUT / PANELS[panel][0]))
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+        ok, img = cap.read()
+        cap.release()
+        if not ok:
+            raise SystemExit(f'cannot read frame {frame_idx} of {PANELS[panel][0]}')
+        if panel == 0:  # the LR source: show its bicubic x4 rendering, same geometry as the others
+            img = cv2.resize(img, (img.shape[1] * 4, img.shape[0] * 4), interpolation=cv2.INTER_CUBIC)
+        tiles.append(label(img[y:y + ch, x:x + cw], PANELS[panel][1] + ' (1:1 zoom)', colors[panel]))
+    grid = np.vstack([np.hstack(tiles[:3]), np.hstack(tiles[3:])])
+    cv2.imwrite(str(OUT / '22_poster_detail_zoom.jpg'), grid, [cv2.IMWRITE_JPEG_QUALITY, 93])
+    print('zoom poster written', flush=True)
+
+
+def label(img, text, bar_color=(255, 255, 255)):
+    bar = np.full((LABEL_H, img.shape[1], 3), bar_color, np.uint8)
+    cv2.putText(bar, text, (8, 21), cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 0), 2, cv2.LINE_AA)
+    return np.vstack([bar, img])
+
+
+def main():
+    clip = cut_clip()
+    cap = cv2.VideoCapture(str(clip))
+    ok, f = cap.read()
+    cap.release()
+    w, h = f.shape[1], f.shape[0]
+    n = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    cap = cv2.VideoCapture(str(clip))
+    frames = []
+    while True:
+        ok, f = cap.read()
+        if not ok:
+            break
+        frames.append(f)
+    cap.release()
+    h, w = frames[0].shape[:2]
+    n = len(frames)
+    print(f'clip: {n} frames @ {FPS} fps, {w}x{h} -> 4x = {w * 4}x{h * 4}, tile={TILE}', flush=True)
+
+    def make_grid():
+        caps = [cv2.VideoCapture(str(OUT / name)) for name, _ in PANELS]
+        writer = Writer(OUT / GRID, (w * 3, (h + LABEL_H) * 2), crf=24)
+        poster = None
+        i = 0
+        while True:
+            imgs = []
+            for cap in caps:
+                ok, img = cap.read()
+                if not ok:
+                    imgs = []
+                    break
+                imgs.append(cv2.resize(img, (w, h), interpolation=cv2.INTER_AREA))
+            if not imgs:
+                break
+            row1 = np.hstack([label(imgs[k], PANELS[k][1]) for k in (0, 1, 2)])
+            row2 = np.hstack([label(imgs[k], PANELS[k][1]) for k in (3, 4, 5)])
+            grid = np.vstack([row1, row2])
+            writer.write(grid)
+            if i == n // 2:
+                poster = grid
+            i += 1
+        for cap in caps:
+            cap.release()
+        writer.close()
+        cv2.imwrite(str(OUT / POSTER), poster, [cv2.IMWRITE_JPEG_QUALITY, 93])
+        print(f'grid video: {i} frames', flush=True)
+
+    if '--grid-only' in sys.argv:          # rebuild the comparison grid from the existing videos
+        make_grid()
+        return
+    if '--poster-only' in sys.argv:
+        build_zoom_poster()
+        return
+
+    results = {}
+
+    def process(name, xml, precision, out_name, reference_jpeg=None):
+        runner = build_torch_runner() if xml is None else RealESRGAN(
+            model=str(ROOT / xml), precision=precision or 'f32')
+        writer = Writer(OUT / out_name, (w * 4, h * 4))
+        times, ps, ss, jpegs = [], [], [], []
+        for i, frame in enumerate(frames):
+            t0 = time.time()
+            out = runner.enhance(frame, tile=TILE, tile_pad=TILE_PAD)[0]
+            times.append(time.time() - t0)
+            writer.write(out)
+            if reference_jpeg is not None:
+                ref = cv2.imdecode(reference_jpeg[i], cv2.IMREAD_COLOR)
+                ps.append(psnr(ref, out))
+                ss.append(ssim(ref, out))
+            else:
+                jpegs.append(cv2.imencode('.jpg', out, [cv2.IMWRITE_JPEG_QUALITY, 95])[1])
+            if (i + 1) % 20 == 0:
+                print(f'  {name}: {i + 1}/{n} frames, {np.mean(times):.2f} s/frame', flush=True)
+        writer.close()
+        total = sum(times)
+        row = {'file': out_name, 'seconds_total': round(total, 2), 'ms_per_frame': round(total / n * 1000, 1),
+               'fps': round(n / total, 2), 'input_mpix_per_s': round(w * h / 1e6 * n / total, 2)}
+        if ps:
+            row['psnr_vs_pytorch'] = round(float(np.mean(ps)), 2)
+            row['ssim_vs_pytorch'] = round(float(np.mean(ss)), 4)
+        results[name] = row
+        print(name, row, flush=True)
+        del runner
+        return jpegs
+
+    ref_jpeg = process('pytorch_fp32', None, None, PANELS[1][0])
+    variants = [('openvino_fp16', 'models/realesrgan_x4plus_fp16.xml', 'f32', PANELS[2][0]),
+                ('openvino_int8_w8a8', 'models/realesrgan_x4plus_int8_w8a8.xml', None, PANELS[3][0]),
+                ('openvino_int4_mixed_w4a16', 'models/realesrgan_x4plus_int4_mixed_w4a16.xml', 'f32', PANELS[4][0]),
+                ('openvino_int4_w4a16', 'models/realesrgan_x4plus_int4_w4a16.xml', 'f32', PANELS[5][0])]
+    for name, xml, prec, out_name in variants:
+        process(name, xml, prec, out_name, reference_jpeg=ref_jpeg)
+
+    make_grid()
+    build_zoom_poster()
+    (OUT / 'metrics.json').write_text(json.dumps(
+        {'clip': {'source': SRC.name, 'frames': n, 'fps': FPS, 'input': f'{w}x{h}',
+                  'output': f'{w * 4}x{h * 4}', 'tile': TILE, 'tile_pad': TILE_PAD,
+                  'seconds': [SS, DUR]},
+         'results': results}, indent=2))
+    print(json.dumps(results, indent=2))
+
+
+if __name__ == '__main__':
+    main()