VELVET VICE LTX — Chunked Image Scale By

The dumbest way to scale up a video clip in ComfyUI is to run the stock ImageScaleBy on the whole batch. It works - right up until the moment the output tensor for a 200-frame clip at 2× turns into a RAM wall and your session dies. VelvetViceLTXChunkedImageScaleBy is the same operation, done the smart way: scale a few frames at a time, into one preallocated output tensor, never materializing the whole upscaled clip at once.

What it is

It's a direct, per-frame analog of ComfyUI's native ImageScaleBy. Same resampling kernels, same rounding - it literally calls comfy.utils.common_upscale, the identical routine the core node uses, with crop: "disabled" so no cropping happens. The node description is precise about what it does not do: no spatial tiling, no temporal interpolation. Each frame is scaled whole; the only novelty is that frames are processed in small batches of frame_chunk_size (default 4) and written straight into a preallocated output tensor, with intermediates deleted per chunk.

Why does that matter for memory? Because a video clip's scaled output is frames × new_height × new_width × channels bytes. At 2×, that's four times the pixels of the input - a 24-second, 720p clip becomes tens of gigabytes of tensor if you build it all at once. Chunking bounds the peak to roughly one chunk's worth of intermediates plus the (unavoidable) full output tensor. You still pay for the output, but you don't pay for a second full-size copy of it while computing.

Inputs and outputs

• image - your frame batch. Accepts [frames, height, width, channels].
• upscale_method - nearest-exact, bilinear, area, bicubic (default), or lanczos. For video, bicubic and lanczos are the usual picks; nearest-exact only if you're doing pixel-art-style output.
• scale_by - 0.01 to 8, default 1.0. The node matches ComfyUI's rounding, so results match the native node exactly.
• frame_chunk_size - 1 to 64, default 4. Lower it on tight RAM; raise it for fewer, bigger ops.
• Output: image, the scaled batch. Wire it into the sampler's image conditioning, the spatial upscaler stage, or a VAE encode.

How it behaves

If the target size equals the input size (e.g., scale_by is 1.0), it short-circuits and returns the input untouched - no wasted work. Each run logs a memory snapshot before and after, and prints the frame count, resolution change, method, and chunk size to the console, which makes it easy to see the peak at the scale stage.

Installing it

Ships in VELVET VICE - LTX (velvet-vice-ltx) - ComfyUI Manager, or:

cd ComfyUI/custom_nodes
git clone https://github.com/Velvet-Vice/velvet-vice-ltx

Restart and hard-refresh with Ctrl+F5. Zero pip dependencies; it only needs ComfyUI's comfy.utils and PyTorch, both always present.

Gotchas

• It's not a diffusion upscaler. This is classic resampling - sharp pixels, no invented detail. The KB's upscaling ladder puts that job on tiled/controlnet upscalers; this node is for the cheap, memory-safe rescale, which is exactly the role it plays in the Velvet Vice workflow's quality pass.
• The whole output still lives in memory. Chunking removes the intermediate copies, not the output. If even the output alone won't fit, you need the FP16 variant (same chunking, half-size output) or to reduce resolution.
• Don't expect temporal smoothing. Per-frame scaling of a video can shimmer on fine detail; that's inherent to the approach and not a bug in the node.

For LTX clips that need a resolution bump before the sampler or a VAE pass, this is the memory-safe way to do it - and if your frames are already FP16, the pack's FP16 variant is the even better match.