Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > ComfyUI-ReCaVSR > ReCaVSR Upscale Video

ComfyUI Node: ReCaVSR Upscale Video

Class Name

ReCaVSRUpscale

Category
ReCaVSR
Author
PedroMarinhoDev (Account age: 50days)
Extension
ComfyUI-ReCaVSR
Latest Updated
2026-11-12
Github Stars
0.03K

How to Install ComfyUI-ReCaVSR

Install this extension via the ComfyUI Manager by searching for ComfyUI-ReCaVSR
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter ComfyUI-ReCaVSR in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

ReCaVSR Upscale Video Description

Upscales videos with one-step diffusion and temporal continuity using memory-efficient streaming.

ReCaVSR Upscale Video:

ReCaVSRUpscale, displayed as “ReCaVSR Upscale Video,” improves video resolution using ReCaVSR’s one-step diffusion super-resolution method. It processes footage as a continuous sequence rather than treating every frame as an unrelated image, using information from earlier processing blocks to guide later ones. Its streaming transformer is based on Wan 2.2 TI2V-5B and processes an initial block of 21 frames followed by blocks of 8 frames. With its streaming FlashDecoder, completed blocks are decoded and encoded directly into a video file, helping you work with longer clips without keeping the entire generated video in memory. This makes the node useful for enlarging footage while managing memory more efficiently than a workflow that stores every generated frame. However, higher resolution still requires substantial GPU memory, and the alternative VAE decoding mode collects intermediate results and decodes them at the end, so it does not provide the same end-to-end streaming memory benefits.

ReCaVSR Upscale Video Input Parameters:

model

A required input of type RECAVSR that supplies the ReCaVSR model bundle, normally connected from ReCaVSRLoader. It provides the transformer, conditioning information, latent-format handling, and the FlashDecoder used by the default decoding mode. This is a specialized model connection rather than a general-purpose diffusion MODEL connection. Its loaded precision and configuration affect resource use during processing. No numeric range or default value is defined; you must connect a compatible RECAVSR model.

scale

A required FLOAT that sets the output dimensions relative to the original dimensions. The default is 4.0, the minimum is 0.5, the maximum is 8.0, and the adjustment step is 0.25. Each output dimension is calculated separately and rounded half up; for example, a 640 × 360 clip at 4.0 becomes 2560 × 1440. ReCaVSR was trained for 4× enlargement, while 2× and 1.5× are additional settings used by the reference implementation. Values below 1.0 request smaller dimensions, although the model is designed for super-resolution. Larger values increase the number of pixels to process and can sharply increase GPU memory requirements. The node may pad dimensions internally for model processing, but the finished video is cropped to the requested calculated size.

color_fix

A required COMBO that controls per-frame color matching between the generated result and the original frame. The options are none, adain, and wavelet, with none as the default. none leaves the generated colors without this additional matching step. adain matches the generated frame’s color mean and variance to the original, helping bring its overall color distribution closer to the source. wavelet preserves the source’s low-frequency information, meaning broad color and tonal structure rather than fine texture. These settings can help when upscaling introduces unwanted color changes, but their effect depends on the footage; compare a short section before processing a long clip.

seed

A required INT that sets the random seed for the noise used by the one-step generation process. The default is 42, the minimum is 0, and the maximum is 18446744073709551615. Keeping this value unchanged helps you compare other settings without also changing the starting noise. Changing it can alter generated detail even when the source footage and other settings stay the same. It does not control the output dimensions or playback speed, and a fixed seed should not be taken as a guarantee of identical results across different hardware, precision settings, or execution modes.

decoder

A required COMBO that selects how the model’s intermediate representation is converted into visible frames. The options are flashdecoder and vae, with flashdecoder as the default. flashdecoder uses ReCaVSR’s low-quality-source-conditioned FlashDecoder and decodes incrementally, allowing completed frames to be encoded while later blocks are still being generated. This is the intended fast, streaming route. vae uses a separately connected Wan 2.2 VAE instead; the node saves generated latents in system memory, combines them after processing all blocks, and then decodes the sequence. This alternative changes the decoding path and increases memory pressure for long clips. Selecting vae requires the vae connection.

kernels

A required COMBO that chooses the implementation of several underlying mathematical operations. The options are fast and exact, with fast as the default. fast uses fused operations and retuned attention processing to improve speed. The node’s tooltip reports approximately 47 dB agreement with the exact path and describes the difference as not visible. Its decoder window kernel requires NVIDIA compute capability 8.0, described in the interface as RTX 30-series or newer. exact follows the reference operation sequence and is intended for reference-output matching rather than maximum speed. If you encounter a fast-kernel compatibility problem, try exact; this does not establish compatibility with every otherwise unsupported device.

kv_offload

A required BOOLEAN with a default of False that controls where the attention history is stored between processing steps. Attention history is information from earlier latent frames that helps guide later blocks. When False, this history stays in GPU memory; when True, it is kept in system RAM between steps, reducing GPU memory use at the cost of transfers between RAM and the GPU. The tooltip estimates approximately 0.8 MB per output token, or around 5 GB for 4× enlargement of 480p footage, as an indication of the memory involved rather than a universal requirement. The node may automatically enable this behavior if its memory estimate indicates that the requested resolution would not otherwise fit. This setting concerns attention history, while ComfyUI separately handles model-weight streaming when needed.

encoder

A required COMBO that controls how completed frames are compressed into the output video. The interface default is auto, and the schema defines the available options as auto plus the entries in ENCODERS; the provided excerpt does not expand that constant into its exact option strings. The documented choices are NVIDIA HEVC encoding, NVIDIA H.264 encoding, and CPU-based H.264 encoding. auto attempts them in that order, and an unavailable selection falls back through the same preference order. The NVIDIA options use dedicated video-encoding hardware with constant-quality settings of 19 for HEVC and 17 for H.264; the documented NVIDIA H.264 limit is 4096 pixels per side. CPU H.264 uses x264 at CRF 14 and is the broadly compatible alternative. This parameter affects compression, encoding performance, and playback compatibility, rather than the model’s super-resolution process.

video

An optional VIDEO input containing the footage to process. You must connect either video or images, but not both. The source video’s frame rate and available audio are carried into the output, and the separate fps setting does not override its frame rate. File-backed videos are read in blocks, making them the more memory-efficient source for long clips. A VIDEO assembled from components is also accepted, but its image frames are already held in memory, so it does not provide the same source-reading memory advantage. No default value or numeric range is defined.

images

An optional IMAGE input containing source frames in their intended playback order. Connect this instead of video when your sequence is already available as an image batch, such as frames created elsewhere in your workflow. The output uses the fps setting and has no audio from this source. Unlike file-backed video, the complete image batch is already held in memory, so long sequences can consume substantial RAM even when decoding and encoding are streamed. No default value or numeric range is defined, and connecting it together with video causes an error.

vae

An optional VAE input for the stock Wan 2.2 VAE, required only when decoder is set to vae. It converts the generated latent sequence into visible frames after all transformer blocks have finished. This path accumulates latents on the CPU and performs the final VAE decode at the end, rather than decoding each block as it is produced. Leave it disconnected when using flashdecoder unless your broader workflow needs the connection elsewhere; this node does not use it in that mode. No default value or numeric range is defined.

fps

An optional FLOAT that sets the output playback frame rate when images is connected. The default is 30.0, the minimum is 1.0, the maximum is 240.0, and the adjustment step is 0.001. For example, 120 supplied frames at 30 fps produce approximately four seconds of video. This setting determines how quickly the existing frames play; it does not generate intermediate frames or perform frame interpolation. When video is connected, the source video’s frame rate is used instead.

ReCaVSR Upscale Video Output Parameters:

VIDEO

A VIDEO object referencing the finished, encoded MP4 file. The file is created in a ReCaVSR subfolder of ComfyUI’s temporary directory, and its dimensions correspond to the source dimensions multiplied by scale, with half-up rounding. It contains the processed source-frame sequence rather than additional interpolated frames. Video sources retain their source frame rate and available audio, while image-batch sources use fps and contain no source audio. Connect this output to Save Video to store the encoded result without re-encoding, or use Get Video Components if you need access to its frames as images. Extracting all frames into an image batch can consume significant memory and removes the practical advantage of keeping the result file-backed.

ReCaVSR Upscale Video Usage Tips:

  • Start with scale = 4.0, decoder = flashdecoder, kernels = fast, color_fix = none, and encoder = auto on compatible hardware. These defaults provide a useful baseline before you adjust color handling or memory settings.
  • For long clips, prefer a file-backed video source and flashdecoder. An image batch already occupies memory, and the vae decoding path accumulates latents before decoding the complete sequence.
  • Test a short representative segment before processing an entire project. Keep seed fixed while comparing scaling, color correction, and decoding settings so that noise changes do not complicate your comparison.
  • If your GPU cannot handle the requested size, lower scale first. Values such as 2.0 or 1.5 are documented reference settings and can substantially reduce the output pixel count.
  • Enable kv_offload when attention history puts too much pressure on GPU memory, provided you have sufficient system RAM. Expect some slowdown from memory transfers; the node may also enable this automatically when needed.
  • Try adain if the result’s overall color distribution drifts from the original, or wavelet if you want to preserve broad source color and tonal structure. Compare the result with none rather than assuming correction is always preferable.
  • Use exact when you need the reference operation sequence or are troubleshooting fast-kernel support. The fast decoder window kernel has a compute-capability requirement, so older GPUs may need this alternative.
  • For image sequences, set fps to the intended playback rate and verify frame order before execution. Changing fps changes duration, not the number of frames or motion smoothness through interpolation.
  • Keep encoder = auto for hardware-aware selection. If you need a broadly compatible playback format, select the CPU H.264 option; if you choose a hardware encoder, check the log for any fallback to another encoder.
  • Save the VIDEO output with Save Video when you want to preserve the encoded result efficiently. Avoid extracting every frame unless your next processing step actually needs an in-memory image batch.

ReCaVSR Upscale Video Common Errors and Solutions:

ReCaVSR Upscale Video needs a video or images connected, one of the two

  • Explanation: This exact error occurs when neither source is connected or when both video and images are connected. The node requires exactly one source.
  • Solution: Connect your clip to video or your ordered image batch to images, and disconnect the other input.

decoder = vae needs the Wan 2.2 VAE connected

  • Explanation: This exact error occurs when decoder is set to vae but the vae input is empty.
  • Solution: Connect a compatible Wan 2.2 VAE, or switch decoder to flashdecoder to use the decoder supplied through the ReCaVSR model bundle.

ReCaVSR at WIDTHxHEIGHT needs about N GiB of VRAM for activations even streamed; this card has M GiB. Lower scale to about S or less, or upscale a smaller input.

  • Explanation: This is the node’s explicit memory-check error, with dimensions, memory estimates, and a suggested scale substituted at runtime. The estimated working memory for the requested resolution exceeds its GPU budget even after the available streaming adjustments. This budget is based on 85% of the device’s total memory.
  • Solution: Reduce scale to approximately the suggested value or lower, or use a smaller source. Shortening the clip alone does not resolve this per-resolution working-memory limit. Moving attention history to RAM cannot eliminate every GPU memory requirement.

CUDA out of memory

  • Explanation: This is a possible underlying runtime error rather than a custom error string in this class. Actual GPU memory availability can differ from the node’s estimate because of other workloads, model allocations, or final VAE decoding.
  • Solution: Lower scale, free GPU memory used by other applications or workflows, and try kv_offload = True if sufficient RAM is available. If you selected vae, switch to flashdecoder to avoid the final whole-sequence VAE decoding path.

Fast-kernel compatibility or compilation failure

  • Explanation: The exact message depends on the kernel runtime and hardware. The documented fast decoder window kernel requires compute capability 8.0, and fast execution also relies on the relevant optimized-kernel support being available.
  • Solution: Try kernels = exact and check that your ComfyUI-ReCaVSR installation has its required dependencies. If the problem continues, inspect the full error for the specific unsupported operation rather than assuming that changing this setting guarantees device compatibility.

Output video encoding fails

  • Explanation: The exact message comes from the encoding implementation and is not shown in the supplied class. Possible causes include an unavailable hardware encoder, unsupported output dimensions or frame rate, or a failure of the available fallback encoders. A logged encoder change alone is normal fallback behavior, not necessarily an error.
  • Solution: Try encoder = auto or the CPU H.264 option. Check your requested dimensions, particularly the documented 4096-pixel-per-side limit for NVIDIA H.264, and review the log to see which encoder was actually selected.

System memory runs out or processing becomes unresponsive

  • Explanation: This is a possible resource problem rather than an explicit validation error. Large image batches, component-based videos, CPU-stored attention history, and the vae path’s accumulated latents can all consume system RAM. In particular, streaming generation does not make an already loaded image batch memory-free.
  • Solution: Use a file-backed video with flashdecoder where possible, reduce the output resolution, and process shorter sections if necessary. Enable kv_offload only when your system has enough RAM to accommodate the moved attention history.

Output file cannot be written or finalized

  • Explanation: The node creates an MP4 inside ComfyUI’s temporary directory. Insufficient disk space, missing write permissions, or an inaccessible temporary location can prevent file creation or completion; the exact error depends on the filesystem or writer.
  • Solution: Check free space on the drive containing ComfyUI’s temporary directory and ensure ComfyUI can write there. For long clips, allow room for the growing encoded file and save the completed result to your intended permanent location.

ReCaVSR Upscale Video Related Nodes

Go back to the extension to check out more related nodes.
ComfyUI-ReCaVSR
RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

ReCaVSR Upscale Video