basicIn_media_unpack

basicIn_media_unpack is the counterpart to the pack's media hubs: the hubs collect a pile of mixed material onto one wire, this node takes that wire back apart. If the pack's stage workflows look clean, it's because hubs and unpacks are doing the wire management.

The two settings that matter

output_index (an INT, default 1, up to 5000) and shot_mode (a boolean). Everything else is inputs.

The index counts per type, not across everything. Connect three videos, three images and three text blocks, set output_index to 2, and you get the second video, the second image and the second text, all at once, each on its own output. That's the one thing to internalise, because the natural reading - "index 2 means item 2 in the bundle" - is wrong and will have you chasing a phantom off-by-one.

The four outputs are index_video, index_text, index_image and index_audio. Wire each to whatever needs it. If the index runs past the end of a lane, that lane is blocked rather than errored - downstream nodes just don't execute. That's deliberate, and it's why a missing output is usually "my index is too high", not "the node broke".

How it decides what's what

Every input declares its own type. You get media (the hub wire) plus media_1 through media_64, each paired with a media_type_N string. Give media_type_1 the value video and that socket is treated as video no matter what's actually plugged in; image or image_batch for images, audio for audio, and batch or text for text. Leave the field blank and the node guesses from the payload: a string is text, a dict with a waveform is audio, something with get_components is video, a 4D tensor is an image, a list of strings is text.

That guessing is mostly reliable - except for text that arrives as a list of strings, as it does out of the pack's own prompt nodes. Declare it batch and each element becomes an indexed text entry. Skipping that step is the classic way to get one giant text block where you wanted shot four.

Text is also split on segment headers. A single string containing #segment 1--------- style markers (or the 【Segment 1】 variant) is torn into one entry per segment, so a shot list authored as one blob addresses cleanly by index.

shot_mode, which is the clever bit

With shot_mode off, you're indexing raw lanes. With it on, you index text segments and the node reads the material tags inside the selected segment to decide what to hand you. Write a shot that says "Picture 2 holds the pose, Video 1 drives the camera" and the node outputs that exact image on index_image, that exact video on index_video, and the segment's text on index_text. The tag syntax is lenient - <Picture 1>, Picture #1, 图片 1, with or without brackets, case-insensitive, and Video/Audio do the same for the other lanes. If the segment references nothing that resolves, all four outputs block.

The practical effect is a shot list that routes its own references. You add a shot to the story, tag which material it uses, and the graph follows - no re-wiring between takes.

Under the hood, and why it stays cheap

Each media_N input is declared lazy, and the node implements check_lazy_status to ask only for the sockets the current index actually needs. In plain ComfyUI every connected input gets evaluated; here, a pose video you aren't referencing this run never gets pulled. That's why this node is worth using even when you could technically wire things directly: it turns a bundle of expensive inputs into one decode instead of six.

Installing it

ComfyUI Manager → ComfyUI-Apt_Preset, or:

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

Restart ComfyUI; it lives under Apt_Preset → IO_Port, next to basicIn_media.

Where it frustrates people

The per-type indexing above is the big one. The second is silent blocking: nothing ran, nothing errored, and the fix is to lower the index or add a media_type_N. The third is type mismatch at the ends - the outputs are VIDEO, STRING, IMAGE and AUDIO specifically, so index_video won't plug into an image input even if the payload would have worked, and you'll want the pack's type-conversion nodes or a decode in between. And because the frontend draws the hub's wires rather than real links, a socket can look empty while still resolving at run time - check the node's actual connections when something seems disconnected.