You do not need a graphics card. Someone else can run the model. Here is how that works, what it costs you in limits, and when a local GPU is still the right answer.
A cloud upscaler uploads the file, runs it on a remote GPU, and returns the result. Your machine only handles the browser. A four year old laptop, a phone, a tablet — all behave the same, because none of them touch the model.
The hardware on the other end matters more than yours. On a rented RTX 5090 or 3090 a single photo finishes in under a minute, which is faster than most people's home cards would manage even if they had one.
| Constraint | Typical cloud limit | Local GPU alternative |
|---|---|---|
| Photo size | 4 MP | No cap |
| Video length | 30 seconds | No cap |
| Setup | None | Vulkan runtime, model download, build |
| Privacy | File leaves your device | Stays local |
| Offline use | No | Yes |
| Cost | Free during launch | Free, open source |
Cut at keyframes so nothing is re-encoded:
ffmpeg -ss 00:01:12 -to 00:01:38 -i input.mp4 -c copy segment.mp4
Batch split a long file:
ffmpeg -i input.mp4 -c copy -f segment -segment_time 30 -reset_timestamps 1 seg-%03d.mp4
Rejoin without a second encode:
printf "file '%s'\n" seg-*.mp4 > list.txt
ffmpeg -f concat -safe 0 -i list.txt -c output.mp4
-ss/-to cut is not frame-exact: it overshoots the tail by 2–3 frames,
and in 2 of 5 tested cut points it duplicated one frame and dropped another. It also produced
larger files per frame than a CRF 18 re-encode. Numbers in the next section.
Stream copy is the standard advice for splitting a file under an upload cap, and nobody usually checks whether the frames that come out are the frames that went in. So I built a fixture where frame identity is readable after compression: 300 frames at 25 fps, 320×180, each carrying its own index as a 9-bit black/white patch in the top-left corner. The patch survives H.264 because its blocks are flat, so after decoding I can read back exactly which source frame each output frame came from — not estimate it, read it.
The source was encoded with libx264 at CRF 18, -g 60, which in practice
produced 23 I-frames over 300 frames (one every ~13 frames). Reading all 300 frames back gave
300 unique, strictly increasing indices — the fixture is self-consistent, so any anomaly
afterwards belongs to the cut, not to the measurement.
Five cut points, each run twice: -ss before -i (input
seeking) and -ss after -i (output seeking). A 1.00 s window
at 25 fps should yield 25 frames. Head and tail error are in frames.
| Cut | Want | Before -i | head / tail | After -i | head / tail |
|---|---|---|---|---|---|
| 0.5 – 1.5 s | 25 | 27 | 0 / +2 | 24 | +3 / +2 |
| 1.0 – 2.0 s | 25 | 27 | 0 / +2 | 20 | +7 / +2 |
| 2.0 – 3.0 s | 25 | 27 | 0 / +2 | 25 | +2 / +2 |
| 2.4 – 3.4 s | 25 | 28 | 0 / +3 | 22 | +6 / +3 |
| 5.0 – 6.0 s | 25 | 28 | 0 / +3 | 25 | +3 / +3 |
Input seeking never lost the head — it starts on the nearest keyframe at or before the requested time — but it overshot the tail by 2–3 frames on all five cuts, which is 8–12% more frames than asked for. Output seeking did the opposite: it dropped 2–7 frames off the front, and in the worst case (1.0 s in, 1.0 s window) delivered 20 frames instead of 25 — a 20% shortfall with no error message and exit code 0.
Worse than a length error: in 2 of 5 cuts in each mode, the output contained one duplicated frame and one missing frame. At the 2.4 s cut the last two frames decode to identical indices. The bit-flags in that frame were unambiguous (block means 234.0 vs 12.0, no value anywhere near the 128 threshold), and the two decoded frames are byte-identical — so this is a real repeated frame, not a misread patch. If you are cutting a clip to a musical beat or a specific cue, that is the frame that slips.
The reason given for copying is always "no generation loss". Noise-free, yes. Cheaper, no. Measured on this fixture:
| Path | Frames | Bytes | Bytes / frame |
|---|---|---|---|
| Source (CRF 18, 300 frames) | 300 | 3,842,297 | 12,808 |
| Stream copy, 1.0–2.0 s | 27 | 465,352 | 17,235 |
| Re-encode, CRF 18, 1.0–2.0 s | 25 | 302,107 | 12,084 |
The copy cut costs 43% more per frame than re-encoding at CRF 18 — because it carries an extra frame, and because the segment it copies still contains the keyframe it started on plus the dependent frames that follow. The re-encode was also exact: 25 frames, indices 25 through 49, no gaps, no duplicates, 41.51 dB PSNR against the source. At CRF 18 on real footage that quality loss is not visible; on a 30 second clip it is also not slow.
Which is the point: when the cap is a hard upload limit, the thing you want to minimise is bytes that fit, not "encodes performed". A re-encode at a sane CRF wins on size, on frame accuracy, and on length predictability at the same time.
The batch-split-then-concat recipe does hold up, and I want to be precise about why, since the section above sounds like it contradicts it. Splitting into 2-second chunks and rejoining gave back exactly 300 frames with 0 missing, 0 duplicated, and PSNR 99.0 (i.e. bit-identical) against the source for all 300 frames. Total size grew 0.1%.
| Segment | Frames | First idx | Last idx |
|---|---|---|---|
| seg_000 | 52 | 0 | 51 |
| seg_001 | 52 | 52 | 103 |
| seg_002 | 52 | 104 | 155 |
| seg_003 | 71 | 156 | 226 |
| seg_004 | 59 | 227 | 285 |
| seg_005 | 14 | 286 | 299 |
Note the chunk sizes: a nominal 2-second segment holds 52, 52, 52, 71, 59 and 14 frames, not
50 each. The muxer snaps chunk boundaries to keyframes, so segment length is "at least
segment_time", never exactly it. If a platform counts frames or enforces a hard
per-file length, budget for that overshoot instead of trusting the number you passed in.
-ss/-to -c copy to hit
an exact time: not safe, expect 2–3 extra frames at the tail, up to 7 missing at the head,
and an occasional duplicated frame. If the cut has to be exact, re-encode it.
While checking how much a re-encode costs, I chained five CRF 23 re-encodes of the same file and measured PSNR after each. Measured against the immediately previous generation, quality improved every round — 32.23 → 40.32 → 41.36 → 42.19 → 43.50 dB. That reads like "re-encoding makes it better", which is nonsense. Measured against the original source, the same five files fall monotonically: 32.23 → 31.75 → 31.38 → 31.11 → 30.91 dB.
| Generation | PSNR vs previous | PSNR vs source | HF energy | Bytes |
|---|---|---|---|---|
| 1 | 32.23 | 32.23 | 62.41 dB | 1,357,687 |
| 2 | 40.32 | 31.75 | 61.54 dB | 1,232,486 |
| 3 | 41.36 | 31.38 | 61.07 dB | 1,108,860 |
| 4 | 42.19 | 31.11 | 60.70 dB | 999,604 |
| 5 | 43.50 | 30.91 | 60.42 dB | 918,020 |
Both series are correct; they answer different questions. Each encode converges toward the "easy to encode" version of the input, so the step size shrinks — that is what PSNR-vs-previous measures. What the viewer sees is distance from the original, which grows. Two baselines are worth keeping apart, because I conflated them myself on the first pass:
If you evaluate denoise or upscale settings by comparing to the previous step, you will systematically pick the setting that destroys the most detail — because destruction is what makes the next step cheap. Always keep an untouched copy as the reference.
Self-contained: builds the fixture, makes both cuts, then prints which source frames
survived. On ffmpeg 6.1.1 this prints n=27 first=25 last=51 and
n=20 first=32 last=51 for the two modes.
import numpy as np, subprocess
W, H, N, BLK = 320, 180, 300, 20 # 300 frames, 9-bit index patch
def frame(i):
yy, xx = np.mgrid[0:H, 0:W].astype(np.float32)
cx = W * (0.3 + 0.4 * i / N) # slow pan
r = np.sqrt((xx - cx) ** 2 + (yy - H * 0.5) ** 2)
g = np.clip(90 + 90 * np.exp(-(r / 90) ** 2)
+ np.random.default_rng(i).normal(0, 9, (H, W)), 0, 255)
img = np.stack([g.astype(np.uint8)] * 3, -1)
for b in range(9): # index as black/white bits
x0 = 2 + b * (BLK + 1)
img[2:2 + BLK, x0:x0 + BLK] = 235 if (i >> b) & 1 else 12
return img
enc = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-f", "rawvideo",
"-pix_fmt", "rgb24", "-s", f"{W}x{H}", "-r", "25", "-i", "-",
"-c:v", "libx264", "-crf", "18", "-g", "60", "src.mp4"],
stdin=subprocess.PIPE)
for i in range(N):
enc.stdin.write(frame(i).tobytes())
enc.stdin.close(); enc.wait()
for tag, args in {"before-i": ["-ss", "1.0", "-to", "2.0", "-i", "src.mp4"],
"after-i": ["-i", "src.mp4", "-ss", "1.0", "-to", "2.0"]}.items():
subprocess.run(["ffmpeg", "-y", "-v", "error"] + args + ["-c", "copy", f"{tag}.mp4"],
check=True)
def read(p): # which source frames survived
raw = subprocess.run(["ffmpeg", "-v", "error", "-i", p, "-f", "rawvideo",
"-pix_fmt", "gray", "-"], capture_output=True).stdout
out = []
for f in np.frombuffer(raw, np.uint8).reshape(-1, H, W):
bits = 0
for b in range(9):
x0 = 2 + b * (BLK + 1)
if f[6:18, x0 + 4:x0 + 16].mean() > 128:
bits |= 1 << b
out.append(bits)
return out
for tag in ("before-i", "after-i"): # want 25 frames, 25..49
ids = read(f"{tag}.mp4")
print(f"{tag:9s} n={len(ids):2d} first={ids[0]:2d} last={ids[-1]:2d}")
A better GPU does not fix wrong ordering. Enlarging first teaches the model the compression blocks and enlarges them too. Do it this way instead:
Past roughly 2x the model starts inventing instead of reconstructing. Faces go waxy, small text becomes letter-shaped strokes. A 540p source at 2x reaches 1080p, which is enough for anything watched on a screen.
Yes, by processing on someone else's hardware. A cloud upscaler runs the model remotely and returns the result to your browser. The tradeoff is upload limits.
For short files the model quality can be identical — same class of model, better hardware. Cloud is limited by size and time caps, not by quality.
Expect tight ones. UpgoLAB takes photos to 4 MP and clips to 30 seconds, then deletes files after an hour.
A photo is usually under a minute. A 30 second clip takes longer because every frame is processed.
No. The phone only uploads and downloads; processing happens at full resolution on the server.
UpgoLAB is the cloud option described here — eight presets by damage type, free during launch, no card, no watermark. Drop a file and it runs on a remote GPU, so the hardware section above is somebody else's problem.
If you do own a GPU and need longer files: comparison with Video2X, Upscayl and Topaz. What is actually fixable in a blurry clip: blurry video guide.