Load Last Frame (FFMPEGA)

Short clips are the honest constraint of local video generation. Wan 2.2 gives you 81 frames - about five seconds - and if you want thirty seconds of a shot, you get there by chaining generations, handing each one the frame the previous one ended on. Load Last Frame is the read side of that handoff. It picks up whatever Save Last Frame put in a named slot so a later queue run can start where the last one finished.

Worth saying up front, because it's the most common mistake with this pair: if both nodes live in the same workflow, don't use this one. Use Save Last Frame's last_frame output directly. Two unconnected nodes have no guaranteed execution order, and ComfyUI decides caching before execution starts, so this node would hand your sampler the previous run's frame. This node exists for the case where the save happened in an earlier run - a continuation session, not a graph-internal wire.

The four required settings

• slot_name - must match Save Last Frame's slot name exactly. Discovery is deterministic: the slot directory is derived from the name and files inside carry fixed zero-padded names, so there's no mtime race against everything else in your output folder.
• refresh_mode - auto reloads whenever the slot's contents change; manual only re-runs when an input changes. Leave it on auto for a chain you're actively iterating on. Under the hood this is an IS_CHANGED method that hashes the slot directory, so auto is what makes a new frame actually invalidate the cached node.
• frame_count - how many of the slot's trailing frames to load, capped at whatever the slot actually holds.
• offset_from_end - skip N frames at the end, mirroring the save side's widget of the same name.

Optional bits worth knowing

on_missing (default fallback) decides what happens when the slot is empty - which is always the case on the first run of a chain. fallback uses the fallback_image input, empty returns a black frame, error stops the run with a message. Wire your original start image into fallback_image and run 1 and run N are literally the same graph with no rewiring; skip it and you get a black frame that silently poisons the generation instead of failing loudly.

source_folder abandons the slot convention entirely and reads an arbitrary folder, picking files by modification time since the naming convention can't be assumed there. filename_filter narrows that to files starting with a prefix. trigger is an ordering hint - wire any Save Last Frame output into it to force that node to run first, though the tooltip is honest that this fixes ordering and not caching, so a just-written frame may still need a re-queue. There's also a mask pass-through, and a collapsed block of resize widgets (enable_resize, resize_width, resize_height, upscale_method, keep_proportion, pad_color, crop_position, divisible_by, resize_device) that stays tucked away until you turn it on. If you're feeding a 720p tail into a model that wants multiples of 32, that block is where you fix it - divisible_by does the rounding.

Outputs: images (oldest first - feed the last one into your i2v model), mask (a solid white mask matching the frames), image_path, width, height, and frame_count, which returns 0 when the slot was empty and is your fastest way to tell "empty slot" from "model problem".

Install

ComfyUI Manager → search ComfyUI-FFMPEGA → Install, or:

cd ComfyUI/custom_nodes
git clone https://github.com/AEmotionStudio/ComfyUI-FFMPEGA.git
pip install -r ComfyUI-FFMPEGA/requirements.txt

Restart. Nothing to download - it's reading PNGs off disk, so the only external requirement is FFMPEG on PATH (which this pack assumes for everything). Like Save Last Frame, it renders a thumbnail strip of the slot inline so you can see which frame you're continuing from before you queue.

Where people get burned

The black frame. First run of a chain, empty slot, on_missing left on fallback and fallback_image unconnected. You get a black start frame and a five-second clip of nothing much, with no error anywhere. Connect the fallback image before you run, every time.

Sequential chaining compresses quality. The community's long-form approach for a reason: each continuation is one generation removed from the original, and degradation accumulates until faces drift. The alternative that avoids it is generating several clips from the same source and using their frames as keyframes, so nothing is more than one hop away. SVI-style extension LoRAs are the other live path on plain Wan 2.2.