> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.ltx.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.ltx.io/_mcp/server.

# SDR to HDR

> Convert supported SDR footage into HDR EXR frames and a BT.2020/HLG master with the LTX-2.5 SDR-to-HDR IC-LoRA in ComfyUI or Python.

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](/open-source-model/vfx-post-production/working-with-exr-hdr#native-hdr) instead.

## Supported surfaces

| Surface | Entry point                                | Output                                                                     |
| ------- | ------------------------------------------ | -------------------------------------------------------------------------- |
| ComfyUI | `LTX-2.5_ICLoRA_SDR_to_HDR_Distilled.json` | ACEScg EXR sequence by default, BT.2020/HLG master, and tonemapped preview |
| Python  | `python -m ltx_pipelines.hdr_ic_lora`      | Scene-linear ACEScg EXR sidecar by default and BT.2020/HLG master          |

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](https://huggingface.co/Lightricks/LTX-2.5-22b-IC-LoRA-SDR-To-HDR)

| File                                                   | Role                                                          | ComfyUI placement                  |
| ------------------------------------------------------ | ------------------------------------------------------------- | ---------------------------------- |
| `ltx-2.5-22b-distilled-transformer-bf16.safetensors`   | LTX-2.5 distilled transformer                                 | `ComfyUI/models/diffusion_models/` |
| `ltx-2.5-video-vae-bf16.safetensors`                   | Diffusion-decoder video VAE; best-quality workflow option     | `ComfyUI/models/vae/`              |
| `ltx-2.5-video-vae-conv-bf16.safetensors`              | Convolutional video VAE; faster, lower-memory workflow option | `ComfyUI/models/vae/`              |
| `ltx-2.5-22b-ic-lora-sdr-to-hdr-1.0.safetensors`       | SDR-to-HDR IC-LoRA                                            | `ComfyUI/models/loras/`            |
| `ltx-2.5-22b-ic-lora-sdr-to-hdr-scene-emb.safetensors` | Precomputed text embeddings                                   | `ComfyUI/models/embeddings/`       |

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

## Inputs

| Input             | Requirement | Notes                                                                                                             |
| ----------------- | ----------- | ----------------------------------------------------------------------------------------------------------------- |
| SDR video         | Required    | In ComfyUI, use an SDR video file. The Python API also supports a directory of EXR frames.                        |
| Input color space | Required    | Use the transform that matches the source pixels. Ordinary display-referred SDR video normally uses `srgb_gamma`. |
| Frame count       | Required    | The generated frame count follows the `8k+1` structure.                                                           |

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

### Input color-space values

| Value        | Use for                                  |
| ------------ | ---------------------------------------- |
| `srgb_gamma` | Ordinary display-referred SDR video      |
| `srgb`       | Scene-linear sRGB input                  |
| `acescg`     | SDR EXR input already encoded as ACEScg  |
| `acescct`    | SDR EXR input already encoded as ACEScct |

## Run in ComfyUI

1. Install [ComfyUI-LTXVideo](https://github.com/Lightricks/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](/open-source-model/vfx-post-production/native-resolution); 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

| Node                         | What it does                                                                              |
| ---------------------------- | ----------------------------------------------------------------------------------------- |
| **LTXVSDRToHDRWorkingSpace** | Applies the declared input transform and maps the frames into ACEScct for conditioning.   |
| **LTXVLoadConditioning**     | Loads the precomputed scene embeddings from `ComfyUI/models/embeddings/`.                 |
| **LTXVHDRDecodePostprocess** | Produces the tonemapped preview and HDR output, including the configured EXR color space. |
| **LTXVSaveHLG**              | Writes the BT.2020/HLG 10-bit master and can mux source audio.                            |

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

## Run with Python

```bash
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](https://huggingface.co/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](/open-source-model/vfx-post-production/working-with-exr-hdr):

* [Viewing EXR files](/open-source-model/vfx-post-production/working-with-exr-hdr#viewing-exr-files)
* [Importing EXR files into DaVinci Resolve](/open-source-model/vfx-post-production/working-with-exr-hdr#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](/open-source-model/vfx-post-production/working-with-exr-hdr)
* [Native Resolution](/open-source-model/vfx-post-production/native-resolution)
* [IC-LoRA Adapters](/open-source-model/reference/ic-lora-controls)
* [Using ComfyUI with LTX](/open-source-model/integration-tools/comfy-ui)
* [PyTorch API](/open-source-model/integration-tools/pytorch-api)