You need to agree to share your contact information to access this model

By clicking "Agree and Access" you acknowledge the Privacy Policy and consent to receive offers and updates. You can unsubscribe at any time.

LTX-2.5 22B IC-LoRA SDR-To-HDR

Converts 8-bit standard-dynamic-range (SDR) video into 16-bit high-dynamic-range (HDR) video, using the SDR clip itself as the control signal and writing EXR output in addition to an HLG master.

It is based on the LTX-2.5 foundation model.

In the examples below, the SDR reference is stacked on top of the generated HDR result. Best viewed on an HDR display, where the recovered highlight range is actually visible.

Prompt: No prompt needed

Prompt: No prompt needed

Prompt: No prompt needed

Model Files

ltx-2.5-22b-ic-lora-sdr-to-hdr-1.0.safetensors

ltx-2.5-22b-ic-lora-sdr-to-hdr-scene-emb.safetensors

Rank-128 adapter. The second file holds the precomputed text embeddings the pipeline expects — see Prompting.

Model Details

Base Model: LTX-2.5-22B Video (the distilled checkpoint is used at inference)
Training Type: IC-LoRA (video-to-video)
Control Type: full-length SDR reference video
Reference Downscale Factor: 1 — the reference shares the target's spatial and temporal grid
Audio: Not trained for audio generation

Intended Use

Converting finished SDR footage into an HDR deliverable — expanding highlight headroom and recovering range that was compressed out by an SDR grade. The output is a sequence of EXR frames in ACEScg, intended to be taken into a grading or finishing pipeline rather than viewed directly. An HLG MP4 is written alongside them so the result can be checked without that step.

Control Signal Requirements

Control signal type: The SDR clip being converted, supplied at full length.
Expected input: An SDR MP4/MOV, or a directory of EXR frames.
Preprocessing: Handled by the pipeline — an input device transform to ACEScct. Choose the transform with --input-colorspace (srgb_gamma, srgb, acescg, acescct).
Alignment: Frame-aligned one-to-one with the output. The reference is appended with the same RoPE time boxes as the target, so attention lines up by timestamp.
Mask support: None. The conversion applies to the whole frame.

How It Works

The SDR clip is encoded and appended to the sequence as a frozen reference at strength 1.0, while the frames being generated start from pure noise. All of the control therefore comes from attending to that clean reference, which is what keeps the result aligned to the SDR source. Denoising is a single stage of 8 distilled Euler steps.

On top of that, the pipeline adds extra single-frame tokens at every segment border, and each border carries two of them at once: a generated HDR slot, which the model fills in freely, and a 1-frame SDR guide at the same position, which stays 95% locked to the source frame. That lock is what keeps the conversion anchored to the original content at each border, while the co-located slot generates a high-information HDR keyframe there — a single frame carrying its full detail, generated uncompressed rather than as part of a compressed span. The generated slots are then decoded jointly with the video volume, sharing a single attention pass, so the high-information detail held in those keyframes is carried into the decoded result instead of staying confined to the keyframe planes.

The decoded result is ACEScct, exported as scene-linear ACEScg EXR frames alongside an HLG BT.2020 10-bit master.

Usage

This model runs on a dedicated pipeline — it needs the ACEScct input transform, the seam-keyframe conditioning and the HDR export path. See Pipeline Details.

The base weights come from the LTX-2.5 split pack — ltx-2.5-22b-distilled-transformer-bf16.safetensors and ltx-2.5-video-vae-bf16.safetensors. Nothing else is needed; there is no text encoder at runtime.

python -m ltx_pipelines.hdr_ic_lora \
  --input clip.mp4 \
  --input-colorspace srgb_gamma \
  --output-path clip_hdr.mp4 \
  --transformer-path ltx-2.5-22b-distilled-transformer-bf16.safetensors \
  --video-vae-path ltx-2.5-video-vae-bf16.safetensors \
  --hdr-lora ltx-2.5-22b-ic-lora-sdr-to-hdr-1.0.safetensors \
  --text-embeddings ltx-2.5-22b-ic-lora-sdr-to-hdr-scene-emb.safetensors \
  --exr-colorspace acescg \
  --keyframe-strength 0.95 \
  --no-quantization

Seam keyframes are enabled by default; pass --no-keyframes to turn them off.

From Python:

from pathlib import Path

import torch
from ltx_core.model.video_vae import AUTO_TILING
from ltx_pipelines.hdr_ic_lora import HDRICLoraPipeline
from ltx_pipelines.utils.media_io import EXRColorSpace, VideoInput, encode_video
from ltx_pipelines.utils.model_paths import ModelPaths

pipeline = HDRICLoraPipeline(
    model_paths=ModelPaths.from_split(
        transformer_path="ltx-2.5-22b-distilled-transformer-bf16.safetensors",
        video_vae_path="ltx-2.5-video-vae-bf16.safetensors",
    ),
    hdr_lora="ltx-2.5-22b-ic-lora-sdr-to-hdr-1.0.safetensors",
    text_embeddings_path="ltx-2.5-22b-ic-lora-sdr-to-hdr-scene-emb.safetensors",
    quantization=None,
)

with torch.inference_mode():
    acescct_hdr, fps = pipeline(
        video=VideoInput(path=Path("clip.mp4"), gamma_encoded=True),
        seed=42,
        tiling_config=AUTO_TILING,
        keyframe_strength=0.95,
    )
    encode_video(
        video=acescct_hdr,
        fps=round(fps),
        audio=None,
        output_path="clip_hdr.mp4",
        video_chunks_number=1,
        color_space=EXRColorSpace.ACESCG,
    )

keyframe_strength=None disables seam keyframes, the equivalent of --no-keyframes. For an EXR-frame source, import EXRVideoInput from the same module and pass EXRVideoInput(dir=..., color_space=..., frame_rate=...) in place of VideoInput.

Using in ComfyUI

Install ComfyUI-LTXVideo.
Load the dedicated SDR-to-HDR IC-LoRA workflow, which wires the SDR reference video, the scene embedding and the HDR export.
Place ltx-2.5-22b-ic-lora-sdr-to-hdr-1.0.safetensors and ltx-2.5-22b-ic-lora-sdr-to-hdr-scene-emb.safetensors where the workflow's loaders expect them, and connect your SDR clip as the reference video.

Pipeline Details

A single-stage pipeline that denoises the whole clip in one window:

Ingest — decode, apply the input device transform to ACEScct, reflect-pad to a multiple of 32.
Condition — encode the clip once and append it as a frozen full-clip reference at strength 1.0. With keyframes enabled, every segment border additionally receives both a 1-frame SDR guide and an empty generated HDR slot.
Denoise — 8 distilled Euler steps, no CFG, no spatial guidance. After each step the reference is forced back to the encoded SDR and the guides are held at 95%.
Decode — the generated slots are extracted and handed to the VAE alongside the video volume, so the clip and the keyframe planes mix in one joint attention pass.
Export — an HLG BT.2020 10-bit HEVC master, plus an EXR sidecar written next to it (scene-linear ACEScg by default; --exr-colorspace acescct writes log codes instead).

Recommended Settings

LoRA strength / weight: Fixed at 1.0 and not exposed on the CLI. This is a full-strength control adapter, not a style LoRA to dial back.
Inference steps: 8, using the distilled sigma schedule. No classifier-free guidance.
Resolution & frames: Runs at the source resolution; the frame count must be 8k+1.
Conditioning frame rate: Best results come from keeping the transformer's RoPE time base at or below 30. The pipeline already handles this, so if you are using it there is nothing to set. Only the RoPE clock is affected; the input and output frame rates are unchanged.
Keyframe strength: 0.95 — the default and the trained value. Do not set it to 0.0: that does not turn the guides into generated keyframes, it converts them into fully denoised tokens of the wrong class.
Input color space: Use --input-colorspace srgb_gamma for ordinary display-referred SDR files. Reserve srgb for scene-linear input, and acescg / acescct for SDR EXR sources already in those spaces.
Quantization: Prefer --no-quantization for best quality. The default is an FP8 cast, which is faster and lighter.
Prompting: None needed. Ship ltx-2.5-22b-ic-lora-sdr-to-hdr-scene-emb.safetensors and pass it to --text-embeddings. The adapter was trained with a single fixed caption, so there is no text encoder at runtime and no prompt to write — the conversion is driven entirely by the reference video.

References

Paper: HDR Video Generation via Latent Alignment with Logarithmic Encoding
Project page: LumiVid HDR
Code: GitHub Repository
ComfyUI: ComfyUI-LTXVideo

Tips & Troubleshooting

Out of memory during decode, not denoise. Long or large plates can denoise successfully and then fail in the VAE. Shorter trims at the same resolution are the quickest way around it.
Reproducibility depends on free VRAM. Decode tiling is chosen automatically from the memory available at the time, so a busy GPU can pick a different layout and shift the result slightly. Run on an idle device when comparing outputs.
Check which EXR space you asked for. The sidecar defaults to scene-linear ACEScg; --exr-colorspace acescct writes log codes instead.

Dataset

The model was trained on a proprietary HDR dataset of paired SDR and HDR clips.

Training

Technique: IC-LoRA on the frozen LTX-2.5-22B base, conditioned on a full-clip SDR reference, with generated seam keyframes and SDR keyframe guides enabled during training.
Hyperparameters: rank 128, alpha 128, bf16.
Steps: 5000.
Infrastructure: LTX-2 Community Trainer.