SDR to HDR

SDR to HDR converts 8-bit standard-dynamic-range video into a gradeable HDR result. The LTX-2.5 IC-LoRA uses the SDR clip itself as a full-length control signal and writes half-float EXR output by default, with float32 available, alongside a BT.2020/HLG 10-bit master.

This is a reconstruction workflow: the model synthesizes highlight range and detail that were compressed out by the SDR grade. It does not recover the original scene data. If the source already contains HDR range, use Native HDR on the Working with EXR & HDR page instead.

Supported surfaces

Both surfaces use ACEScct internally. The current ComfyUI workflow saves scene-linear ACEScg EXR by default; change the post-process node’s exr_color_space to acescct when your finishing pipeline requires log-encoded ACEScct output. The Python pipeline also defaults to scene-linear ACEScg EXR and can export ACEScct.

Model files

Model card: LTX-2.5 22B IC-LoRA SDR to HDR

The conversion uses fixed precomputed embeddings. It does not load a text encoder at runtime and does not require a prompt.

Inputs

The control applies to the whole frame. The model does not support a conversion mask.

Input color-space values

Run in ComfyUI

1. Install ComfyUI-LTXVideo.
2. Load LTX-2.5_ICLoRA_SDR_to_HDR_Distilled.json.
3. Place the SDR-to-HDR adapter and scene-embedding files where the workflow’s loaders expect them.
4. Load the SDR source video and choose the input transform that matches it.
5. Run the workflow and save the configured EXR sequence, HLG master, and tonemapped preview.

For larger output canvases, use the separate LTX-2.5_V2V_TiledFusion_SDR_to_HDR.json workflow. It uses Tiled Fusion; follow the model selections embedded in the workflow.

The ComfyUI graph can retain source audio and mux it into the HLG master. The IC-LoRA itself was not trained for audio generation.

When the source frame rate is above 30 fps, the current graph uses 30 fps for model conditioning while retaining the source frame rate for output playback.

Key nodes

The post-process node’s exposure control changes only the SDR preview. It does not change the HDR output.

Run with Python

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

The pipeline writes the HLG MP4 to --output-path and an EXR sidecar next to it. The default EXR representation is scene-linear ACEScg; use --exr-colorspace acescct when you need log-encoded ACEScct frames.

Seam keyframes are enabled by default. Use --no-keyframes to disable them. The Python pipeline does not pass through source audio.

For an EXR-frame source, use EXRVideoInput through the Python API and provide the directory, source color space, and frame rate.

Users who notice artifacts in high-contrast details can experiment with disabling generated seam keyframes from VAE decoding. This requires modifying the pipeline; it is not exposed as a CLI option.

How the conversion works

1. The pipeline decodes the source, applies the selected input transform to ACEScct, and pads the image dimensions as needed.
2. It encodes the full SDR clip as a frozen, frame-aligned reference at strength 1.0.
3. With seam keyframes enabled, each segment border receives an SDR guide plus a generated HDR slot. The guide remains anchored to the source while the HDR slot can reconstruct detail.
4. A single stage performs eight distilled Euler denoising steps without classifier-free guidance.
5. The video and generated keyframe slots are decoded together, then exported as an HLG master and EXR sidecar.

Pipeline constraints and resource considerations

• The IC-LoRA runs at its fixed full strength of 1.0.
• The trained seam-keyframe strength is 0.95. Use --no-keyframes to disable seam keyframes; do not use a strength of 0.0 as a substitute.
• The pipeline runs at the source resolution. Frame count must follow 8k+1.
• Keep the transformer’s conditioning time base at or below 30 fps. The dedicated pipeline handles this without changing the input or output frame rate.
• Disabling quantization uses more memory and may improve output fidelity. Use quantization when reducing memory use is more important.
• Large or long plates may complete denoising and then run out of memory during VAE decode. Shorter trims at the same resolution are the quickest way to reduce decode pressure.
• Decode tiling is selected from available VRAM, so run comparisons on an otherwise idle GPU for the most reproducible result.

Legacy LTX-2.3 workflow

The LTX-2.3 HDR IC-LoRA remains a separate LogC3 workflow with its own model stack and color interpretation.

Model: Lightricks/LTX-2.3-22b-IC-LoRA-HDR (ltx-2.3-22b-ic-lora-hdr-0.9.safetensors)

Do not substitute its adapter, scene embeddings, checkpoint, or output transform for the LTX-2.5 files described above. Use a version-matched legacy package when reproducing the LTX-2.3 Python path; the current command on this page documents LTX-2.5.

Viewing and grading the output

For OCIO-aware viewer setup and DaVinci Resolve import, use the shared sections on Working with EXR & HDR:

• Viewing EXR files
• Importing EXR files into DaVinci Resolve

Assign the input transform that matches the EXR representation you exported. Do not assign an ACEScct transform to scene-linear ACEScg frames, or an ACEScg transform to ACEScct log frames.

Related pages

• Working with EXR & HDR
• Native Resolution
• IC-LoRA Adapters
• Using ComfyUI with LTX
• PyTorch API