HDR Generation and SDR-to-HDR

Our Beyond8Bits, the largest HDR video set we could find, has 6,861 source videos, and InternVid alone holds 234 million SDR clips. Generators therefore learn from 8-bit SDR, and HDR has to be recovered from an SDR picture or steered out of a pretrained sampler toward light it never saw.

Thesis. Most image and video generators learned from 8-bit SDR pictures. Our Beyond8Bits, the largest HDR video set we could find, has 6,861 source videos[1], against 234 million SDR clips in InternVid[2]. So HDR is recovered from an SDR picture, called inverse tone mapping, or steered out of a pretrained generator, and both are judged with tools that cannot show the result.

State. From 2007 to 2020, inverse tone mapping gained about 4 points on HDR-Eye in HDR-VDP-2 Q, a 0 to 100 quality score, fewer than the 7.35 points that score can resolve[3]. LumaFlux gains only 0.49 dB of perceptual PSNR over the best fixed conversion.

Implication. Report several metrics and expect them to disagree. Viewers ranked our LumaGuide above a fine-tuned competitor, and an automatic score ranked it below[4]. Every image here is SDR, an input, a rendering of an HDR frame or a preview of an HDR result.

What SDR threw away

An HDR video stores brightness far above the white of an ordinary screen, in skies and clouds most of all. The figure below cuts three such videos off at that white, then dims them so the clouds, sky and mountains the cut erased come back into view.

Clipped at 100 nits
3 stops down
Luminance in nits
Dusk sky over a building with every pixel brighter than 100 nits clipped: the upper sky is flat white and the building wall is white. The same dusk frame three stops darker: a band of gray storm cloud, small white clouds against blue above it, and a sunlit tan wall. Luminance map of the dusk frame: the sky and the building wall in orange and yellow, above 100 nits, the trees in purple. A river with the sky clipped to plain white and the bright water near the camera washed out. The same river frame three stops darker: a deep blue sky with thin streaks of cloud, and their reflection on the water. Luminance map of the river frame: sky and water in orange, above 100 nits, the wooded bank in purple. A valley with the sky clipped to white: the mountain range behind the valley has vanished. The same valley frame three stops darker: a snow-covered mountain range against a glowing sky, with small lights in the valley. Luminance map of the valley frame: the sky in yellow and orange, the mountain in orange and red, the ground in purple.
Frames from three Beyond8Bits HDR videos[5], hard clipped at 100 nits, a constructed clip harsher than a real SDR grade, then dimmed by 3 stops, then mapped to luminance. In each frame 49.7 to 55.0 percent of the pixels sit above 100 nits and turn pure white in the clip.

Luminance is measured in nits (cd/m2), dynamic range in stops. One stop is a factor of 2, so a range from \(L_{\min}\) to \(L_{\max}\) spans \(\log_2(L_{\max}/L_{\min})\) stops. Standard dynamic range (SDR) video is graded, meaning its tones are set by hand on a reference monitor, so that diffuse white, the luminance of a matte white surface under the main light, sits at 100 nits over a reference black below 0.01 nits[6].∗ High dynamic range (HDR) keeps the levels above diffuse white, and PQ, its main encoding curve, runs to 10,000 nits[7][8].

∗BT.2035 writes the 100-nit white down as a grading convention, and BT.2100 copies it into its PQ reference chain.

HDR screens are already in phones and living rooms. iPhones have stored HDR highlight data with their photos since 2020[9]. Legacy film and TV is SDR[10], and diffusion generators trained on SDR images are limited to SDR output[11]. In linear form, generated HDR also lights virtual objects in rendering[12].

Scenes span more than SDR carries. Fairchild's survey metered one outdoor scene, PaulBunyan, from 0.010 to 4,780 nits, 18.9 stops, a lower bound from seven spot readings[13]. The BT.2035 white and black give SDR 13.3 stops on paper, but the 8-bit file sets the floor. Video files put black at code 16 and white at 235, called narrow range, so the first code above black is 1/219 of the BT.709 signal. The BT.709 camera curve is a straight line of slope 4.5 near black, which ties that code to 0.1 percent of clip white, 9.9 stops down[14], and anything darker is black in the file. The histogram at the top shows the other end, where moving the SDR white changes how much of the scene lands on the single top code. Its three scenes are illustrative shapes we drew, and none is a measurement.

Four many-to-one maps

An HDR scene loses information in four places on its way into an 8-bit SDR file. Write \(L\) for absolute luminance in nits, \(L_w\) for diffuse white at 100 nits, and \(T\) for the camera encode curve. First, highlights clip.

\[ V = T\big(\mathrm{clip}(L / L_w)\big), \qquad \mathrm{clip}(x) = \min(x, 1) \]

\(V\) the normalized SDR code value, \(L/L_w\) luminance relative to diffuse white

Every luminance from \(L_w\) to the scene maximum lands on code 235 in narrow range or 255 in full range. In PQ, 100 nits encodes to 0.508[8], so the clip folds the top 49 percent of the PQ signal, 100 to 10,000 nits or 6.6 stops, into one value. Sun, glints, lamps and sky leave as one white.

Second, the signal is quantized. Bit depth is the number of bits per color channel, and 8 bits give 256 codes and a step of 1/255.

\[ Q(V) = \frac{\mathrm{round}(255\,V)}{255} \]

\(V \in [0, 1]\) the encoded signal before rounding

A fixed step in code is a variable step in nits. For full-range codes through BT.1886, the standard SDR display curve with an exponent of 2.4, at 100-nit white and zero black[15], the step to the next code is:

8-bit code \(n\)\(L(n)\), nitsstep to \(n+1\), nits\(\Delta L / L\)
160.1300.02015.7%
643.620.1373.8%
12819.10.3611.9%
25499.10.9390.9%

Banding is the visible result when neighboring codes differ by more than the eye's contrast threshold, and a smooth sky or shadow gradient breaks into flat contours. Every step in the table is larger than the threshold from Barten's model of contrast sensitivity, 0.43 percent at 1 nit and 0.22 percent at 100. The margin grows toward black, where the relative steps from code 32 down run from 7.7 to 428 percent.

Third, colors clip to the gamut. An SDR file can only name chromaticities, meaning hue and saturation without brightness, inside its gamut, the triangle its three BT.709 primaries span on the CIE 1931 xy chromaticity diagram. By triangle area, computed from the primaries the standards list[14][16][17], 47.1 percent of the wide BT.2020 triangle and 26.3 percent of the P3-D65 display triangle lie outside it. After a 3 by 3 matrix \(M\) into BT.709 RGB, each channel is clipped to the unit range.

\[ (R', G', B') = \min\!\big(\max(M\,[R, G, B]^{\top}, 0), 1\big) \]

\([R, G, B]\) the wide-gamut linear color, \((R', G', B')\) the clipped BT.709 color, \(\min\) and \(\max\) taken per channel

Every out-of-gamut color moves onto the triangle's edge. A soft-knee mapper avoids the crease by desaturating in-gamut colors too, which spreads the collision. At 8 bits, the mean CIELAB color difference \(\Delta E^*_{ab}\) between consecutive codes is 35 percent larger with BT.2020 primaries than with BT.709, and the maximum falls below 1 only at 10 bits[18].

Fourth, the transfer functions, the curves between light and code values, disagree. Tone mapping compresses the luminance of a scene or HDR master into a target display's range, through a tone-mapping operator (TMO). SDR and HDR codes come from different chains:

\[ V_{\mathrm{SDR}} = T_{709}\big(\mathrm{TMO}(L)\big), \qquad E' = \mathrm{EOTF}_{\mathrm{PQ}}^{-1}(L) \]

\(T_{709}\) the BT.709 encode, \(\mathrm{EOTF}_{\mathrm{PQ}}^{-1}\) the PQ encode from nits to signal, \(E'\) the PQ signal for the same luminance \(L\)

Where nothing clips or bands, an SDR code still does not give \(L\) without the TMO and its parameters, and files do not store them. Even the reference renderings differ. BT.2100 renders PQ by passing scene light, scaled by 59.5208, through the SDR encode and decode, and renders HLG, the broadcast HDR curve, with a different, peak-dependent gamma[8].

Each of the four sends many inputs to one output.

Transfer functions decide where the codes go

A file stores code values, a display emits light, and three curves connect them. The opto-electronic transfer function (OETF) maps scene-linear light \(E\) at the camera to a signal \(E'\). The electro-optical transfer function (EOTF) maps a signal to display luminance \(L\) in nits. The opto-optical transfer function (OOTF) is the end-to-end map from scene light to display light. SDR video uses the BT.709 OETF[14] at the camera and the BT.1886 EOTF[15] at the display:

\[ L \;=\; a\,\big(\max(V + b,\ 0)\big)^{\gamma}, \qquad \gamma = 2.40 \]

\(V\) the normalized signal, \(L_W\) and \(L_B\) the display white and black in nits, \(a = (L_W^{1/\gamma} - L_B^{1/\gamma})^{\gamma}\), \(b = L_B^{1/\gamma} / (L_W^{1/\gamma} - L_B^{1/\gamma})\)

BT.1886 leaves \(L_W\) free, and BT.2035 pins 10-bit code 940 to 100 nits and code 64 to below 0.01 nits[6]. The BT.709 camera curve has a nominal exponent of 0.45, but its offset and straight-line toe make the effective exponent about 0.5. The display decodes with 2.4, so the SDR chain carries an end-to-end gamma of about 1.2[19]. Web images use sRGB instead, with the BT.709 primaries and an 80-nit reference display[20].

PQ, the Perceptual Quantizer of SMPTE ST 2084[7], starts from the display side. Its EOTF maps a signal \(E' \in [0, 1]\) to absolute luminance with a fixed 10,000-nit peak, and its inverse is what a grading tool writes into the file:

\[ \begin{aligned} L &= 10000\,Y, \qquad Y = \left( \frac{\max\!\big(E'^{1/m_2} - c_1,\ 0\big)}{c_2 - c_3\,E'^{1/m_2}} \right)^{1/m_1}, \\[6pt] E' &= \left( \frac{c_1 + c_2\,Y^{m_1}}{1 + c_3\,Y^{m_1}} \right)^{m_2} \end{aligned} \]

\(Y = L/10000\) the normalized luminance. From BT.2100 Table 4, \(m_1 = 2610/16384 = 0.1593017578125\), \(m_2 = 2523/4096 \times 128 = 78.84375\), \(c_1 = 3424/4096 = 0.8359375\), \(c_2 = 2413/4096 \times 32 = 18.8515625\), \(c_3 = 2392/4096 \times 32 = 18.6875\), and \(c_1 = c_3 - c_2 + 1\) so that \(Y = 1\) encodes to \(E' = 1\)

The inverse EOTF puts 100 nits at \(E' = 0.508\), 1,000 nits at 0.752 and 4,000 nits at 0.903, which are 10-bit narrow-range codes 509, 723 and 855, and 10,000 nits at code 940[8]. SDR white uses barely half the PQ code range, and the transfer curves show how much of the vertical axis each curve gives to light above 100 nits.

0.000111001,00010,00000.51luminance (nits, log scale)signal value SDR gammaHLGPQ
Signal value against luminance for the BT.1886 display gamma[15], which runs out of codes at its 100-nit white, for PQ[7], which puts the marked 100 and 1,000 nits at 0.51 and 0.75 of an absolute 0.0001 to 10,000-nit range, and for HLG[21]. HLG is scene-relative, and the curve here is for a 1,000-nit display through the BT.2100 OOTF with system gamma 1.2.

HLG, Hybrid Log-Gamma from ARIB STD-B67[21], starts from the camera side. BT.2100 defines it by an OETF on scene light with a relative peak[8]. For a scene-linear component \(E \in [0, 1]\):

\[ E' = \begin{cases} \sqrt{3E}, & 0 \le E \le \tfrac{1}{12} \\[4pt] a \ln(12E - b) + c, & \tfrac{1}{12} < E \le 1 \end{cases} \]

\(a = 0.17883277\), \(b = 1 - 4a = 0.28466892\), \(c = 0.5 - a\ln(4a) = 0.55991073\). Both branches give 0.5 at \(E = 1/12\), and the log branch reaches 1 at \(E = 1\)

The square-root branch covers shadows and mid-tones, and the log branch compresses highlights. Signal 1.0 means the peak of whatever display plays it, so one file shows 1,000 nits on a 1,000-nit monitor and 400 on a 400-nit one. The display decodes with the inverse OETF and then applies the OOTF:

\[ \begin{aligned} L &= \alpha\,Y_S^{\gamma - 1}\,E, \qquad Y_S = 0.2627\,R_S + 0.6780\,G_S + 0.0593\,B_S, \\[6pt] \gamma &= 1.2 + 0.42 \log_{10}\!\left(\frac{L_W}{1000}\right) \end{aligned} \]

\(R_S, G_S, B_S\) the scene-linear components, \(E\) any one of them and \(L\) the displayed light of that component in nits, \(Y_S\) their luminance, \(\alpha = L_W\) the display's nominal peak in nits, \(\gamma\) the system gamma, 1.2 at a 1,000-nit peak and defined this way from 400 to 2,000 nits

The system gamma is 1.033 at 400 nits and 1.326 at 2,000, which adjusts the mid-tones to the display peak. A PQ file carries absolute nits, and an HLG file carries values relative to that peak.

Bit depth decides whether these curves band. Over narrow-range 10-bit codes 64 to 940[8], PQ spends 50 to 66 codes on every stop from 10 nits to 10,000 and still 18 codes on the stop that starts at 0.1 nits. An 8-bit gamma-2.4 curve with a 100-nit white gives that stop 4.1 codes, the stop at 0.01 nits 1.6, and the stops above 100 nits none. BT.2246 takes the eye's contrast threshold from Barten's contrast sensitivity model and finds that 10-bit gamma 2.4 crosses it while 12 bits stays below[18]. BT.2390 runs the same test on PQ and finds that 12-bit PQ stays below the threshold from 0.001 to 10,000 nits, that 10-bit PQ sits above it "to some extent", and that camera noise masks the predicted banding in practice[19].

We reran the test on PQ with Barten's 1999 contrast sensitivity function, the viewing constants of BT.2246 and its conversion from sensitivity to minimum detectable contrast. BT.2246 gives no field size or photon conversion factor, so we set them to 60 degrees and \(1.2274 \times 10^6\), and from 100 nits up our threshold comes out at about half the curve BT.2390 prints, which is why 12-bit PQ lands just above it here. The step is the relative change in luminance from one full-range code to the next:

luminance (nits)detection threshold12-bit PQ stepratio10-bit PQ stepratio
0.012.19%2.28%1.049.32%4.3
10.43%0.48%1.111.93%4.5
1000.22%0.24%1.110.98%4.5
1,0000.20%0.22%1.120.90%4.5

A 10-bit PQ step is 4.0 to 4.1 times a 12-bit step at every level. The 8-bit gamma curve with a 100-nit white lands 17.7 times above our threshold at 1 nit and 10.5 times at 10 nits, which is why 8-bit SDR bands in the shadows.

SDR also caps color. The three color spaces compared here share D65, the standard daylight white, at (0.3127, 0.3290). BT.709 puts red, green and blue at (0.640, 0.330), (0.300, 0.600) and (0.150, 0.060)[14]. P3-D65, the cinema P3 primaries with the D65 white, moves them to (0.680, 0.320), (0.265, 0.690) and (0.150, 0.060)[17]. BT.2020 places them on the spectral locus, the horseshoe curve of single-wavelength colors, at 630, 532 and 467 nm, or (0.708, 0.292), (0.170, 0.797) and (0.131, 0.046)[16]. Against the area inside the spectral locus, computed from the 5 nm CIE 1931 2-degree color matching functions[22], the triangles cover 33.6, 45.6 and 63.6 percent. BT.2020 has 1.89 times the xy area of BT.709. On the chromaticity diagram the green primary moves farthest between the three spaces.

0.00.20.40.60.80.00.20.40.60.8CIE 1931 xCIE 1931 y480 nm520 nm560 nm600 nmBT.2020P3-D65BT.709D65
The CIE 1931 chromaticity diagram[22] from the 2° color matching functions at 5 nm steps, with the BT.709[14], P3-D65[17] and BT.2020[16] primaries and the D65 white. The triangles cover 33.6, 45.6 and 63.6 percent of the area inside the spectral locus and its closing line of purples.

A gamut is two-dimensional and carries no luminance. A color volume adds the luminance axis and holds every color a file or display can produce at every level from black to peak. SDR's volume is BT.709 up to 100 nits. The PQ container is BT.2020 up to 10,000 nits, although only white reaches that peak. Pure BT.2020 blue tops out at 593 nits, so the real volume tapers toward white. HDR10, the open baseline format, is PQ with BT.2020 primaries at 10 bits plus static metadata about the mastering display[23]. On a log luminance axis the color volume plot shows how much of that container an SDR picture leaves empty.

Two color volumes over the CIE xy chromaticity floor with luminance on a log axis from 0.0001 to 10,000 nits, the SDR volume as the BT.709[14] triangle extruded to 100 nits inside the PQ container, the BT.2020[16] triangle extruded to 10,000 nits. The straight prisms are a simplification, because a real color volume tapers toward white as luminance rises.

Tone curves that make SDR, and the HDR left to learn from

SDR made from an HDR master or a camera signal passes through a TMO that fits the luminance into the 100-nit SDR range. Reinhard et al. scale the image so that its average lands on a chosen key, the display value given to middle gray, then compress it with a rational curve[24]:

\[ L_s = \frac{a}{\bar L}\,L, \qquad \bar L = \exp\!\Big(\frac{1}{N}\sum_{i=1}^{N} \log(\delta + L_i)\Big), \qquad Y_d = \frac{L_s\,\big(1 + L_s / L_{\mathrm{white}}^2\big)}{1 + L_s} \]

\(L\) is scene luminance, \(\bar L\) its log-average over the \(N\) pixel values \(L_i\) with a small \(\delta\) that keeps the log finite, \(a\) the key, 0.18 by default and varied up to 0.36 in the paper for low-key scenes, \(Y_d\) normalized display luminance, and \(L_{\mathrm{white}}\) "the smallest luminance that will be mapped to pure white".

Both \(a\) and \(L_{\mathrm{white}}\) are per-image choices, and \(\bar L\) depends on the whole frame, so the same scene luminance lands on different codes in different pictures.

ACES is the film industry's color pipeline, and its reference rendering maps scene light to each display through a tone curve. Game engines ship Narkowicz's 2016 approximation of it instead[25]:

\[ f(E) = \frac{E\,(2.51E + 0.03)}{E\,(2.43E + 0.59) + 0.14} \]

\(E\) is the scene-linear input and \(f(E)\) the linear display value, the BT.709 output with its 2.4 gamma removed.

The curve is a hand fit to ACES with a maximum error of 0.0138. It is pre-exposed, so the input needs a 0.6 scale to match ACES. It fits luminance only and over-saturates bright values.

Most live SDR was made in the camera, which applies the BT.709 curve[14] and, past a knee point, rolls highlights off toward 109 percent, so light a few stops over white keeps a gradient. BT.2390 calls this shoulder "implemented in the camera as a camera knee"[19], and it is set per production and stored in no metadata.

The four losses that open this section compose into one forward map, \(f_{\mathrm{SDR}} = Q \circ \mathrm{clip} \circ T_{709} \circ \mathrm{TMO} \circ \mathrm{gamut}\), with \(Q\) the 8-bit quantizer and \(T_{709}\) the SDR encode. Each stage loses information and the TMO's parameters are stored nowhere, so \(f_{\mathrm{SDR}}\) has no inverse. The preimage of an 8-bit SDR pixel is a set, and for a clipped pixel that set runs from 100 nits to the 10,000-nit PQ ceiling. Every SDR-to-HDR method picks one element of that set, by a hand prior, a learned regression, or a generative sample.

Learning that pick takes native HDR, and little of it exists. For video, InternVid alone holds 234 million SDR clips cut from over 7 million videos[2]. The largest HDR video set we could find is our own Beyond8Bits, with about 44,276 clips made from 6,861 sources[1]. That is more than 1,000 SDR videos for every HDR source. The bars below draw the HDR sets on a linear axis and break the SDR bar, which does not fit on it.

SDR video HDR video InternVid Panda-70M WebVid-10M Beyond8Bits SFV+HDR LIVE-HDR HDRTV1K Deep SR-ITM 234M 70M 10M 44,276 2,000 310 22 videos 10 videos 0 10K 20K 30K 40K Clips or videos, linear scale
Video datasets at the count each source publishes, with the HDR sets on a linear axis[2][26][27][1][28][29][30][10]. The SDR bars break at the dots and are not drawn to scale.

We built Beyond8Bits to rate the quality of user-generated HDR video. Its sources are 2,253 crowd-contributed phone recordings and 4,608 Creative Commons Vimeo uploads in 10-bit PQ and BT.2020, and the clips carry over 1.5 million crowd ratings[1]. Its CHUG subset[31] supplies the user-generated HDR that LumaFlux trains on, and about 24,000 of its frames fit LumaGuide's text-to-histogram regressor.

HDR video that comes with an SDR partner is thinner still. Supervised SDRTV-to-HDRTV work, the conversion of broadcast SDR video to HDR, trained from 2019 to 2024 on 44K YouTube frames from 7 videos[10], on HDRTV1K's 1,235 training frames from 18 videos, whose SDR side is YouTube's automatic down-conversion[30], or on 3,878 hand-picked HDRTV4K frames[32]. Beyond8Bits itself has no SDR ground truth.

Images fare no better. Native HDR image sets that can be downloaded, such as Fairchild's survey[13], HDR-Eye[33], SI-HDR[3] and the NTIRE training triplets[34], hold at most a few thousand items each.

The scarce data also splits in kind. HDR-Eye and Fairchild hold scene-linear or calibrated radiance, values proportional to scene light. HDRTV1K, HDRTV4K and Beyond8Bits hold display-referred PQ, values that name the light a screen should emit. Pooling the two takes a known OOTF.

Inverse tone mapping, classic to learned

SDR-to-HDR conversion and inverse tone mapping (ITM) name the same task. Given one 8-bit picture, produce the HDR picture it could have come from. Photo papers call the input LDR, for low dynamic range, and their LDR-to-HDR line, from HDRCNN and SingleHDR to the diffusion methods, predicts linear scene radiance, usually up to an unknown scale. The SDRTV-to-HDRTV line predicts the display-encoded signal, 10-bit PQ in a BT.2020 container. The two share almost no test sets, and their metrics do not transfer[30]. This section follows the photo line.

Expansion operators, 2006 to 2009

Banterle et al. linearize the input, then run the global Reinhard operator from the previous section backwards. Solving the sigmoid for its input and keeping the positive root gives, in the form of the 2009 survey[35],

\[ L_w(x) \;=\; \frac{L_{\max} L_{\mathrm{white}}}{2}\left( Y_d(x) - 1 + \sqrt{(1 - Y_d(x))^2 + \frac{4}{L_{\mathrm{white}}^2}\, Y_d(x)} \right) \]

\(Y_d \in [0,1]\) the linearized SDR luminance, \(L_w\) the output luminance in nits, \(L_{\max}\) the chosen peak, \(L_{\mathrm{white}} > 1\) the curve shape

The inverse curve stretches the whole range. To put structure back inside clipped light sources, Banterle adds an expand map, a smooth density built from 1,024 median-cut light samples that weights a blend between the linearized input and the expanded one. Rempel et al. made expansion real time. They stretch linearly from 0.3 to 1,200 nits and multiply in a brightness enhancement function, a blurred mask of near-saturated pixels scaled to [1, 4], for a 4,800-nit peak[36].

Masia et al. tested these operators on over-exposed input and found quality "degrades substantially with over-exposure, to the extent that in some cases subjects prefer the LDR originals"[37]. Their fix is a single global gamma picked from the image key, a number from 0 to 1 that places the average log luminance between the darkest and the brightest pixel,

\[ k \;=\; \frac{\log Y_{\mathrm{avg}} - \log Y_{\min}}{\log Y_{\max} - \log Y_{\min}}, \qquad \gamma \;=\; 10.44\,k - 6.282 \]

\(Y\) the linearized luminance, \(Y_{\min}\) and \(Y_{\max}\) its extremes, \(Y_{\mathrm{avg}}\) its geometric mean with \(\log Y_{\mathrm{avg}} = \frac{1}{n}\sum_x \log(Y(x) + \delta)\) over \(n\) pixels and a small offset \(\delta\), \(k\) the key, and \(Y^{\gamma}\) the output

The regression fits 20 images from five scenes with \(r^2 = 0.82\), and it goes negative when the key is low enough. None of these operators reconstructs anything inside a clipped region. They brighten it, smooth it or leave it flat.

The first CNNs hallucinate highlights

HDRCNN treats ITM as prediction of the saturated pixels only[38]. A VGG16 encoder and a deconvolution decoder emit log HDR, and the output keeps the input wherever it is valid:

\[ \hat H \;=\; (1 - \alpha)\, D^2 + \alpha \exp(\hat y), \qquad \alpha = \frac{\max(0, \max_c D_c - \tau)}{1 - \tau}, \qquad \tau = 0.95 \]

\(D \in [0,1]\) the 8-bit input, \(D^2\) its fixed linearization, \(\hat y\) the predicted log HDR, \(c\) the color channel

The soft blend avoids the banding a binary mask leaves at the highlight edge. The fixed \(x^2\) is also the weak point, because the network learns nothing about the camera response function, or CRF, the monotonic curve a camera applies between sensor exposure and stored code value. DrTMO avoids direct regression. It synthesizes brighter and darker 8-bit exposures at steps of \(\sqrt 2\) and merges them with the Debevec and Malik method[39][40]. It has 48.09M parameters and trained for "about a month on a GeForce GTX 1080". ExpandNet uses three parallel branches with no upsampling, 0.45M parameters, and a cosine term on RGB direction for color[41].

MethodInputOutputLossTraining data
HDRCNN 20178-bit LDR, linearized by \(x^2\)log HDR, blended to linear relative radiancemasked log MSE1,121 images, 67 videos, about 125K crops
DrTMO 20178-bit LDR, 512 by 5128-bit exposure stack, merged up to a global scaleL1 on bracket images1,043 HDR images, 46,935 LDR images
ExpandNet 2018tone-mapped LDRrelative HDR RGB in [0, 1], rescaled to the reference at testL1 + 5 x cosine color term1,013 HDR images, five tone mappers
SingleHDR 20208-bit JPEG, non-linearlinear relative radiance, 32-bit floatone loss per stage103,010,400 pairs from 502 HDR images

Modeling the camera pays off

SingleHDR writes the camera down and inverts it stage by stage[42]. The forward model takes scene radiance \(E\) at exposure \(t\) to 8-bit code values \(V\):

\[ V \;=\; Q(F(C(H))), \quad H = tE, \quad C(H) = \min(H, 1), \quad Q(I) = \frac{\lfloor 255\, I + 0.5 \rfloor}{255} \]

\(F\) an unknown monotonic CRF and \(t\) sampled over \(\log_2 t \in [-3, 3]\) in training. JPEG compression at quality 85 to 100 sits in the training data, outside the model.

Four networks undo that chain in reverse order. A U-Net adds a dequantization residual. A ResNet-18 regresses 11 coefficients of the inverse CRF in the EMoR basis, an empirical model fitted to the DoRF database of measured camera curves, and constrains the curve to be monotonic. A hallucination network adds a non-negative residual where the linear image passes 0.95. A refinement network trained on real exposure stacks absorbs local tone mapping and white balance. In the diagram each network sits under the stage it undoes, and the refinement network has no forward stage above it.

Scene radiance Clip Camera response Quantize SDR image Dequantize Linearize Hallucinate Refine HDR radiance E C F Q V
SingleHDR's camera model for an SDR photograph, top, and the four networks that invert it, bottom[42]. Clipping and quantization map many radiances to one code, so the networks beneath them estimate what the camera discarded.

Trained end to end from scratch, the same capacity loses 4.43 HDR-VDP-2 Q on HDR-Synth, the paper's synthetic test set, and 3.48 on HDR-Real, its real one[42]. Q is a quality score from 0 to 100 computed by a model of human vision, and 100 means no predicted difference. Edge and histogram features plus the monotonic constraint cut inverse-CRF error from 2.00 to 1.56. In 30-pair comparisons with the reference shown, 200 participants preferred SingleHDR over HDRCNN, DrTMO and ExpandNet 70 percent of the time[42]. Its over-exposed regions can still come out "over-smoothed".

Banterle, Rempel, DrTMO, SingleHDR and HDRTVNet model the pipeline explicitly. HDRCNN, ExpandNet and the diffusion methods keep the camera in data synthesis at most. DrTMO gained 1.7 Q from five camera curves over sRGB alone[39]. HDRTVNet's end-to-end variant shows "obvious artifacts in some over-exposed and oversaturated regions"[30], and HDRTVNet++ reports that naive end-to-end training "suffers from severe gamut transition errors"[43]. Two results point the other way. ExpandNet found camera-curve augmentation worth under 1 percent[41], and Rempel found a gamma indistinguishable from a CRF on broadcast material[36]. An explicit pipeline holds up on unknown cameras and avoids gamut errors, but it cannot fill a clipped sky. That takes a learned prior, which the GAN and diffusion methods below add.

Generative ITM and the 8-bit autoencoder

GANs came first. HDR-cGAN hallucinates clipped regions with a pix2pix-style conditional GAN and took the best PSNR on HDR-Eye, a test set of 46 LDR and HDR pairs, with 17.57 dB against 17.12 for ExpandNet, while still losing HDR-VDP-2.2 to SingleHDR, 51.94 against 53.15[44]. GlowGAN drops paired data[45]. A StyleGAN-XL generator emits unbounded radiance, and a random camera clips and tone-maps it before the discriminator sees it.

\[ C(r) = \mathrm{CRF}_{\beta,\gamma}\big(\min(2^{e} r,\, 1)\big), \qquad e \sim \mathcal N(0, \sigma_e^2) \]

\(r\) is the generated linear HDR image, \(e\) a sampled exposure in stops, and \(\mathrm{CRF}_{\beta,\gamma}\) a sigmoid camera curve with \(\beta \sim \mathcal N(0.6, 0.1)\) and \(\gamma \sim \mathcal N(0.9, 0.1)\). Only an image that carries range looks real under every sampled exposure.

GlowGAN turns ITM into GAN inversion, a per-image search for the latent code whose camera rendering matches the input. The dynamic range of its outputs rises from 8.0 to about 20 stops while FID, a distance between generated and real image statistics, moves only from 3.48 to 3.61. Each scene class, such as lightning or fireworks, needs its own model at 256 by 256, and the authors write that the range they get is "tightly linked to the exposure variance in the dataset".

Diffusion ITM inherits the variational autoencoder, or VAE, that compresses 8-bit images into the latent a diffusion model denoises. X2HDR measured what HDR does to it on 512 aligned Blu-ray frame pairs with HDR-VDP-3, which scores in just-objectionable differences, or JOD, with 10 the highest quality. The FLUX.1-dev VAE round-trips LDR at 9.86 JOD, linear HDR at 8.54 and HDR in the perceptual PU21 encoding at 9.44[46].

The diffusion methods differ in how they handle that VAE, and Generating HDR directly has the mechanisms. LEDiff fine-tunes the VAE decoder to emit log-space HDR, and 20 participants preferred it over SingleHDR 89.40 percent of the time[11]. Bracket Diffusion denoises one LDR exposure per bracket on a frozen model, needs 23 GB for five brackets[47] and reaches 11.1 stops of effective range in X2HDR's measurement[46]. X2HDR, DiffHDR and LumiVid put a perceptual or log curve in front of a frozen VAE[46][48][49]. ExpoCM skips the latent and trains a pixel-space consistency model, a network that maps noise to the image in one step, at 0.33 s per 512 by 512 image against 174.10 s for DDPM[50]. LumaFlux, our converter, freezes the FLUX.1-dev VAE and fits a monotone spline to decoded luma[51]. On 117 native pairs it scores 23.56 dB PU21-PSNR in 8 steps, against 18.65 for X2HDR in 30 and 10.99 for LEDiff in 50.

The figure below shows one input and output pair from three of these papers, HDR-cGAN, the conditional diffusion model of Dalal et al. and LumiVid.

Dark SDR photo of a park at night: a bench, a path and one street lamp, with the trees and background lost in black.
SDR input
HDR-cGAN result for the same park, tone-mapped: the bench, the tree trunks and a building behind them are visible.
HDR-cGAN
Overexposed SDR photo of a brick arcade: the far archway and the floor are clipped to white.
SDR input
Result of the Dalal et al. diffusion model for the same arcade: the archway shows a street with trees and the floor tiles have texture.
Conditional diffusion
SDR still of a red car on a mountain road at dusk, the clouds above the ridge flat and gray.
SDR input
LumiVid result for the same still, shown as an exposure fusion: the clouds carry warm highlights and more contrast.
LumiVid
SDR input over method output for HDR-cGAN[44], the conditional diffusion model of Dalal et al.[52] and LumiVid[49]. All six panels are SDR previews from the papers' figures, the LumiVid pair cropped, reproduced under CC BY 4.0 (sources and crops).

Sixteen years inside one metric's noise

HDR-Eye is the only set scored with one metric from the classic operators through a diffusion model[33]. The rows up to 2020 come from SingleHDR's run of HDR-VDP-2[42], and the last two come from their own papers' HDR-VDP-2.2 runs[44][52]. HDR-cGAN's run agrees with SingleHDR's on SingleHDR, 53.15 against 53.16, and on HDRCNN, 50.75 against 50.80, but it puts DrTMO at 48.33 against 51.80 here, a gap of about 3.5 Q. Dalal et al. copy HDR-cGAN's baselines, so only their own row is new.

MethodYearHDR-VDP-2 QRun
AEO, Akyüz et al.200749.20SingleHDR
MEO, Masia et al.200949.28SingleHDR
HPEO, Huo et al.201444.12SingleHDR
KOEO, Kovaleski and Oliveira201449.62SingleHDR
HDRCNN201750.80SingleHDR
DrTMO201751.80SingleHDR
ExpandNet201850.43SingleHDR
SingleHDR202053.16SingleHDR
HDR-cGAN202151.94own, HDR-VDP-2.2
Conditional diffusion, Dalal et al.202352.29own, HDR-VDP-2.2

The chart sets each row against a shaded band that starts at the 2007 operator.

classic learned AEO2007 49.20 MEO2009 49.28 HPEO2014 44.12 KOEO2014 49.62 HDRCNN2017 50.80 DrTMO2017 51.80 ExpandNet2018 50.43 SingleHDR2020 53.16 HDR-cGAN2021 51.94 Dalal et al.2023 52.29 HDR-VDP-2 Q (higher is better)
Filled dots are scores from SingleHDR's tables for itself and the earlier methods[42], and hollow dots are HDR-cGAN's and Dalal et al.'s own HDR-VDP-2.2 runs[44][52], all on the 46 HDR-Eye pairs[33]. The shaded band spans 7.35 Q above AEO, the minimum measurable difference Hanji et al. estimate for this metric[3].

The running best climbs from 49.20 to 53.16 by 2020, a gain of 3.96 Q, and both later generative rows land under SingleHDR. Hanji et al. put the minimum measurable difference for HDR-VDP-2 Q at 7.35 points at α = 0.05, estimated on CRF-corrected images in a 27-image study[3]. By that margin, which we apply here to uncorrected HDR-Eye scores, SingleHDR cannot be told apart from a 2007 expansion operator. Only HPEO, 9.04 below SingleHDR, falls outside that limit. Display settings move Q about twice as far as the 2007 to 2020 gain. ExpoCM's settings put SingleHDR at 45.23[50], 7.93 below the 53.16 that SingleHDR reports for itself.

SingleHDR warns that per-frame use on video "is likely to result in temporal flicking artifacts"[42].

Generating HDR directly

The open generators people fine-tune today are latent diffusion models, or LDMs. A variational autoencoder (VAE) compresses each image into a smaller grid of numbers called the latent, a denoiser learns to generate latents, and the VAE decoder turns the final latent back into pixels. FLUX.1-dev, Wan and LTX use a diffusion transformer (DiT) as the denoiser, trained as a rectified flow. It predicts a velocity \(v_\theta(z_t, t)\) along a straight path from a clean latent \(z_0\) at \(t = 0\) to Gaussian noise at \(t = 1\). Generating HDR directly means getting light above diffuse white out of this pipeline. Published work intervenes at seven places, lettered A to G on the map below.

Data VAE encoder Latent Denoiser VAE decoder Output file Conditioning Sampler E A F D C B G A B C D E F G Latent-space fixes Exposure brackets Sampling-time guidance Fine-tune to emit HDR Lighting and panoramas Physically guided Gain-map delivery
A latent diffusion pipeline from training data to the delivered file, with a letter where each direction intervenes. The comparison table later in this section lists the methods behind each letter.

The prior is 8-bit at both ends

The VAE decoder was trained to reproduce gamma-encoded sRGB pixels in [0, 1], stored as [-1, 1] and clamped on output, so it has no code for 2.0. The denoiser learned latents of clipped, tone-mapped photographs, so it draws a sunlit window as a flat white patch. In LEDiff's words, "pixels that are clipped in the image space are similarly clipped in the latent space"[11]. Pushing real HDR through the frozen encoder fails too. Linear HDR moves FLUX VAE latents to a KL divergence of 0.231 from the SDR latent prior, and input encoded with PU21 stays at 0.033. On X2HDR's Q*PSNR the encode-decode roundtrip scores 27.9 dB for linear HDR, 35.6 dB for PU21 and 38.8 dB for plain SDR[46]. On video, a linear roundtrip through the LTX VAE scores 13.99 dB PU21-PSNR against 29.97 dB with the ACEScct log curve[49], and the Wan VAE gives 22.16 dB linear, 14.61 dB pure log and 32.86 dB log-gamma[48].

So every paper first picks the HDR signal its model sees. Four representations try to fit HDR inside one image the VAE can hold: unbounded linear float as stored in .hdr and .exr files, log radiance, 10-bit PQ, and PU21. Two keep each picture in SDR range and move the range elsewhere. One is an exposure stack of SDR frames at known EV offsets, one EV per stop, merged afterward. The other is an SDR base plus a gain map, a per-pixel brightness ratio that direction G covers.

Direction A: fix the representation at the latent

Direction A fixes the representation the latent has to carry, with a transfer curve applied before the encoder and inverted after the decoder, a tuned decoder, or a head on the latent itself. X2HDR re-encodes HDR in PU21 for FLUX.1-dev[46]. LumiVid uses ACEScct, a camera log curve, for the LTX-2.5 video DiT, picked by minimizing the KL divergence between encoded-HDR and SDR latent statistics, and its first arXiv version used ARRI LogC3[49]. DiffHDR applies a log-gamma curve for Wan-2.1-VACE-14B[48]:

\[ \mathcal{T}(E) \;=\; \left(\frac{\ln(1 + \gamma E)}{\ln(1 + \gamma M)}\right)^{1/\gamma} \]

\(E\) scene-linear radiance, \(M\) the largest radiance the encoding represents, \(\gamma\) a shape parameter, and \(\mathcal{T}(M) = 1\)

LEDiff instead fine-tunes the Stable Diffusion decoder to emit log HDR, with two denoiser copies that shift a latent down and up in exposure before a learned fusion[11]. LatentHDR freezes FLUX.1-dev and trains only a head on 954 HDR panoramas. The head maps one latent to exposure-specific latents and is conditioned by FiLM, a per-channel scale and shift computed from the target exposure[53].

The papers split on touching the VAE. Without decoder fine-tuning, LEDiff's HDR-VDP-3 score falls from 6.16 to 4.67[11]. X2HDR's JOD fell from 7.57 with a frozen VAE to 7.34 with a fine-tuned one[46], and DiffHDR found that "VAE finetuning tends to over-smooth the latent representation and suppress fine details"[48].

Direction B: generate brackets, then merge

Direction B keeps the generator in its 8-bit range, asks for several SDR pictures of one scene at different exposures, and gets the range from Debevec and Malik's 1997 merge[40]. A code value \(N_{ij}\) at pixel \(i\) in exposure \(j\) records irradiance \(E_i\) times exposure time \(\Delta t_j\) through the camera response \(f\), and the merge averages the \(P\) per-exposure estimates of \(\ln E_i\) with a hat weight that ignores clipped codes:

\[ g(N_{ij}) = \ln E_i + \ln \Delta t_j, \quad g = \ln f^{-1}, \qquad \ln E_i = \frac{\sum_{j=1}^{P} w(N_{ij})\,\big(g(N_{ij}) - \ln \Delta t_j\big)}{\sum_{j=1}^{P} w(N_{ij})} \]

\(w(N) = N - N_{\min}\) for \(N \le \tfrac12 (N_{\min} + N_{\max})\) and \(N_{\max} - N\) above it, with \(N_{\min}\) and \(N_{\max}\) the lowest and highest code values

The weight is why hallucinated brackets work. A bracket that blows out a window contributes nothing there if another bracket saw it unclipped, so the burden moves to consistency across brackets. DrTMO began the line in 2017 with a network that emits exposures \(\sqrt{2}\) apart[39]. Bracket Diffusion couples five training-free denoising chains at EV -4 to +4 and reaches 39.4 dB cross-bracket PSNR, which falls as brackets are added[47].† Tedla et al. stack 0 and ±4 EV along the time axis of Wan2.2 for video[54]. LatentHDR gets a stack over EV -7 to +5 from one diffusion run where Bracket Diffusion needs five, and reaches 11.3 stops on SI-HDR[53]. The documented failure is misalignment. Tedla et al. report "ghosting and halo artifacts" from misaligned brackets and "residual clipping" at a fixed ±4 EV spacing[54].

†Bracket Diffusion was titled Exposure Diffusion in its first arXiv version in May 2024 and renamed in March 2025. Both names point to the same paper.

Direction C: steer a frozen sampler

Guidance adds a gradient term to the model's prediction at every sampling step, pulling the trajectory toward samples that satisfy a condition \(y\). A diffusion model learns the score \(\nabla_{x_t} \log p(x_t)\), the gradient of the log density at the noisy sample \(x_t\) of step \(t\). Bayes' rule splits the conditional score into the model's score plus the gradient of a likelihood:

\[ \nabla_{x_t} \log p(x_t \mid y) \;=\; \nabla_{x_t} \log p(x_t) + \nabla_{x_t} \log p(y \mid x_t) \]

Diffusion posterior sampling (DPS) evaluates the likelihood on the model's clean-image estimate, so any differentiable pixel loss becomes a guidance term without a classifier trained on noisy inputs. For a rectified-flow DiT[4]:

\[ \hat{x}_0(z_t) = \mathrm{Dec}\big(z_t - t\,v_\theta(z_t, t)\big), \qquad v_g = v_\theta(z_t, t) + s(t)\,\nabla_{z_t}\, \ell\big(\hat{x}_0(z_t)\big) \]

\(\mathrm{Dec}\) the VAE decoder, \(\ell\) a differentiable loss on the decoded image, \(s(t)\) the guidance scale, and each Euler step moves \(z_t\) along \(-v_g\)

For HDR, \(y\) is an exposure or luminance target. Bracket Diffusion's cross-chain consistency cost is one, weighted by \(\lambda = \lambda_0 (1 - t/T)^2\) over \(T\) steps[47]. LumaGuide matches a PQ-luminance histogram, covered in its own section. Guidance needs no HDR training data and ports across backbones, but it pays a decoder backward pass per step. Saturated pixels cannot be guided back, since "once pixels are clamped to the upper bound, their gradients become zero", and strong guidance brings "banding and unnatural textures"[4].

Direction D: fine-tuning trains a sliver of the backbone

Direction D teaches a pretrained text-to-image or text-to-video backbone a wider output range, on little data. X2HDR trains on 3,278 HDR images[46], LumiVid on about 300 clips[49], LEDiff on 36,000 crops[11]. The backbones run to billions of parameters, so every method freezes most of the network. The usual tool is LoRA, low-rank adaptation. A frozen weight \(W \in \mathbb{R}^{d \times k}\) gets a trainable update \(BA\) of rank \(r\) far below \(d\) and \(k\), adding \(r(d+k)\) parameters per matrix.

X2HDR puts rank-32 LoRA on the attention projections of FLUX.1-dev and trains about 3,000 steps on 4 GPUs, VAE and text encoder frozen. Linear radiance is rescaled to a 4,000-nit peak, PU21-encoded per channel into [0, 1], passed through the frozen VAE and inverted back to linear float. With PU21 its text-to-HDR model reaches 14.2 stops of effective dynamic range. Trained on linear values the same recipe reaches 5.5 stops, and on PQ 14.5[46].

The other methods train on the curves of direction A. LEDiff fine-tunes its decoder for 200k steps and its two U-Net denoisers for 400k[11]. LumiVid trains a rank-128 LoRA on the LTX-2.5 video DiT[49], and DiffHDR a rank-32 LoRA on Wan-2.1-VACE-14B[48]. None of them ships a model trained on linear radiance.

X2HDR, LumiVid and DiffHDR train their LoRAs with flow matching on the latent of the encoded HDR target, the squared error between the predicted velocity and the straight-line velocity from clean latent to noise[46][49][48]. Tedla et al. tune every transformer weight of Wan2.2 the same way[54]. LEDiff's denoisers minimize the squared error on predicted noise, the epsilon loss of Stable Diffusion, and its decoder and fusion module train on a reconstruction loss plus a GAN loss in log space[11].

Whether to tune the VAE decoder follows from the target. LEDiff asks for log radiance, which the stock decoder never produced, so it retrains the decoder. X2HDR and DiffHDR encode into the range the decoder already covers, where retraining cost them detail[11][46][48]. Decoding in BF16, the 16-bit bfloat16 format, can band. X2HDR sees it in about 2 of 100 generations and recommends FP32, full 32-bit floats, when it shows, and DiffHDR keeps its VAE in FP32 for the same reason.

Direction E: lighting and panoramas hit the ceiling first

Direction E is lighting estimation, which outputs an HDR environment map, a panorama of scene radiance that a renderer lights inserted objects with. A map with a clipped sun casts wrong shadows, so this community met the 8-bit ceiling early.

DiffusionLight gets HDR out of SDXL, a model that in its authors' words has "never seen HDR images"[12]. It inpaints a chrome ball into the photo with a depth ControlNet, a side network that conditions SDXL on a depth map, takes the pixel-wise median of 30 seeds, then asks for the same ball darker. A rank-4 Exposure LoRA reads the exposure through an interpolated text embedding,

\[ \xi^{ev} = \xi_o + \frac{ev}{EV_{\min}}\,(\xi_d - \xi_o), \]

\(\xi_o\) the prompt embedding, \(\xi_d\) the embedding of the prompt with "black dark" appended, \(ev \in [EV_{\min}, 0]\) the requested exposure in stops

It trains 2,500 steps, about 5 hours on one RTX 3090 Ti, on 1,412 Text2Light panoramas, with the noise-prediction loss masked to the ball's pixels. At inference it paints balls at EV 0, −2.5 and −5 and replaces pixels above 0.9 with exposure-corrected luminance from the next darker ball, keeping chroma from EV 0 to avoid ghosting. On Laval Indoor, angular error on diffuse, matte and mirror spheres falls to 2.14, 3.42 and 5.94 from StyleLight's 4.24, 4.74 and 6.78, though StyleLight keeps the lower si-RMSE, the scale-invariant RMSE.

Direction F: physics for the range, a generator for the texture

Direction F starts from the camera. A method that models exposure, the camera response, the clip and the 8-bit quantizer knows which pixels clipped and has a lower bound on the radiance under them, so the generator fills texture inside the clipped mask while the physical model fixes the tone scale.

ExpoCM trains a consistency model, a network that maps noise to a clean image in one step, from scratch and builds a soft exposure mask from the 2nd and 98th luminance percentiles. Clipped pixels start from noise, shadows from a low-pass copy of the input, and the rest from the input itself[50]. On HDR-Real, a set of 1,838 pairs, it reaches 28.66 dB mu-law PSNR against 27.64 for Reti-Diff.

LumaFlux also sits here, with luminance descriptors in the attention of a frozen FLUX.1 and a spline tone curve on the decoded output[51], and its own section covers it.

Direction G: gain maps and native outputs

Direction G concerns the file that leaves the pipeline. A gain map is a second 8-bit image stored beside an 8-bit SDR base, holding per pixel the log2 ratio of HDR to SDR luminance. A plain JPEG reader shows the base, and an HDR-aware reader multiplies the ratio back in. Android, Adobe and Apple converged on this layout, and ISO 21496-1 standardized it on 7 July 2025[55][9][56]. The equations are the Android specification's as written. We did not check them against the paywalled ISO text.

\[ \begin{aligned} g(x,y) &= \frac{Y_{\mathrm{hdr}}(x,y) + o_{\mathrm{hdr}}}{Y_{\mathrm{sdr}}(x,y) + o_{\mathrm{sdr}}}, \qquad V(x,y) = \lfloor 255\, r(x,y) + 0.5 \rfloor, \\ r(x,y) &= \operatorname{clamp}\!\left(\frac{\log_2 g(x,y) - \log_2 b_{\min}}{\log_2 b_{\max} - \log_2 b_{\min}},\, 0,\, 1\right)^{\gamma} \end{aligned} \]

\(Y_{\mathrm{sdr}} \in [0,1]\) and \(Y_{\mathrm{hdr}} \in [0, b_{\max}]\) linear luminance in the SDR image's primaries, \(b_{\min} \in (0,1]\) and \(b_{\max} \ge 1\) the min and max content boost, \(o_{\mathrm{sdr}}\) and \(o_{\mathrm{hdr}}\) offsets with 1/64 recommended, \(\gamma > 0\) the map gamma, \(V\) the stored 8-bit code

Decoding scales the exponent by the screen's current headroom, the ratio of the brightest white it can show at that moment to its SDR white.

\[ \begin{aligned} w &= \operatorname{clamp}\!\left(\frac{\log_2 B_{\mathrm{disp}} - C_{\min}}{C_{\max} - C_{\min}},\, 0,\, 1\right), \qquad \hat r = (V/255)^{1/\gamma}, \\ \mathrm{HDR}(x,y) &= \big(\mathrm{SDR}(x,y) + o_{\mathrm{sdr}}\big)\, 2^{\,w\,[\,G_{\min}(1-\hat r) + G_{\max}\,\hat r\,]} - o_{\mathrm{hdr}} \end{aligned} \]

\(B_{\mathrm{disp}}\) the headroom, set by the OS, \(C_{\min}\) and \(C_{\max}\) the log2 boosts at which the map starts to apply and applies fully, \(G_{\min}\) and \(G_{\max}\) the log2 of min and max content boost, SDR and HDR linear RGB

On an SDR display \(\log_2 B_{\mathrm{disp}} = 0\), so \(w = 0\) and the decoder returns the base, and at \(C_{\max}\) the full map applies. The spec suggests a map at a quarter of the base resolution per side, and its worked example spans about 5.3 stops. Apple's Adaptive HDR, adopted in iOS 18, also stores the log of the ratio, with iPhone headroom "greater than 1 and up to 8"[9].

For bracket or guidance output the map is a post-process, and libultrahdr tone-maps the HDR to a base, computes the ratio and writes one JPEG[57].

We found no commercial text-to-image generator that writes HDR or a gain map. Only research releases write native HDR, LumaFlux among them with 16-bit PQ PNG and 10-bit PQ HEVC[51]. ISO 21496-1 covers digital photography only, so video leaves as HDR10.

Seven directions compared

A method can sit in two rows. X2HDR, LEDiff, LumiVid and DiffHDR appear under A for the encoding they train on and under D for how they train, and Bracket Diffusion sits under B for its brackets and under C for the guidance that couples them. The HDR data column counts native HDR items used to train the generator.

DirectionWhat it changesHDR dataVideoRepresentative work
A. Latent-space fixesEncoding, decoder or head300 to 36,000YesLEDiff, X2HDR, LumiVid, DiffHDR, LatentHDR
B. Exposure bracketsBrackets, then a mergeNone to 11,336 clipsYesDrTMO, Bracket Diffusion, Tedla et al.
C. Sampling-time guidanceThe sampler onlyNoneYesLumaGuide, Bracket Diffusion
D. Fine-tune to emit HDRDenoiser weightsSmall or synthesizedMostly ITMX2HDR, LEDiff, LumiVid, DiffHDR
E. Lighting and panoramasWeights and data1,412Input onlyDiffusionLight
F. Physically guidedPhysics plus generatorUp to 314,396Per frameLumaFlux, ExpoCM
G. Gain-map deliveryThe containerNoneNoUltra HDR, ISO 21496-1, Apple Adaptive HDR

Measured limits of the 8-bit prior

LEDiff measures 4.3 stops of effective dynamic range in X2HDR's evaluation and 4.71 in LumaGuide's. LatentHDR scores it at 10.3 stops on SI-HDR and reports that removing its blend with the LDR input leaves 4 to 5. Bracket, PU21 and guidance methods reach 11 to 15[46][4][53].

X2HDR reports that FLUX without fine-tuning gives a "'pseudo-HDR' appearance with exaggerated saturation/contrast and visible clipping artifacts"[46]. LumiVid, trained without degradations, posterizes because the network "learns a shortcut by simply stretching 8-bit steps into linear space"[49]. We found that LoRA or full fine-tuning of the DiT overfits small HDR sets into texture hallucination or unstable luminance[51].

The routes that skip training pay at inference. Bracket Diffusion takes 22 minutes per 256 by 256 image on ADM, the pixel-space ImageNet diffusion model, and about 2 minutes on GLIDE[47]. LumaGuide takes 7.8 s at 512 by 512, against 2.31 s for LatentHDR's single diffusion run and 0.03 s for the feed-forward HDRCNN[38].

LumaFlux and LumaGuide

We built two methods. LumaFlux recovers HDR from an SDR frame by conditioning a frozen FLUX.1-dev, which is direction F. LumaGuide steers a pretrained generator toward a target PQ-luminance histogram with no training, which is direction C.

LumaFlux, a frozen DiT steered by physics and perception

LumaFlux takes an 8-bit BT.709 SDR frame whose tone mapping, gamut compression and codec history are unknown, uses no prompt, and returns 10-bit PQ BT.2020 HDR as HEVC video or 16-bit PNG[51]. It inverts a chain of three lossy stages:

\[ x_{\mathrm{sdr}} = \mathcal{Q}_{\mathrm{codec}}\Big(\mathcal{M}_{2020\to709}\big(\mathrm{TMO}(x_{\mathrm{hdr}};\,\theta_{\mathrm{tone}})\big)\Big) \]

\(x_{\mathrm{hdr}}\) the PQ BT.2020 frame, \(\mathrm{TMO}\) a tone-mapping operator with unknown parameters \(\theta_{\mathrm{tone}}\), \(\mathcal{M}_{2020\to709}\) the gamut matrix to BT.709 primaries, \(\mathcal{Q}_{\mathrm{codec}}\) 8-bit quantization and video compression

A tone mapper squeezes HDR luminance into the SDR range, a matrix shrinks the gamut, and a codec quantizes what is left.

SDR 8-bit BT.709 Physical descriptors SigLIP FLUX.1 DiT Residual coupler FiLM RQS tone head HDR PQ BT.2020 frozen trainable
Physical descriptors and SigLIP features condition a frozen FLUX.1-dev transformer, and a monotone spline on the decoded luma carries the range expansion to 10-bit PQ BT.2020[51]. The drawing omits the frozen VAE, the low-rank adapter and the per-block conditioner.

The physical path linearizes the frame in BT.2020 primaries, \(x_{\mathrm{lin}}\), and reads luminance \(Y = \mathbf{m}_{2020}^{\top} x_{\mathrm{lin}}\) with \(\mathbf{m}_{2020} = [0.2627, 0.6780, 0.0593]^{\top}\). Three descriptors come out of \(Y\).

\[ \begin{aligned} T_{\mathrm{phys}} &= \mathrm{Conv}_{3\times3}\big([\,Y,\ \log(1+|\nabla Y|),\ \mathrm{sat}\,]\big) \\ g &= \mathrm{MLP}_g\big([\mu_Y, \sigma_Y, p_{95}, p_{99}]\big),\qquad r \in \mathbb{R}^{K} \end{aligned} \]

\(\mathrm{sat}\) the saturation channel, \(\mu_Y, \sigma_Y\) the mean and standard deviation of \(Y\), \(p_{95}, p_{99}\) its percentiles, \(r\) the log mean energy of a 2-D Fourier transform of \(Y\) in \(K = 8\) radial bands

\(T_{\mathrm{phys}}\) gives each token its local brightness, edges and saturation, \(g\) the exposure of the whole frame, and \(r\) its spatial-frequency content.

On the perceptual path, SigLIP, a frozen image encoder, turns the SDR frame into tokens \(T_{\mathrm{perc}}\). A trainable connector \(C_{\mathrm{perc}}\) projects them to the width of the MM-DiT, the FLUX.1 transformer, and places them in its text stream beside 8 learned null tokens. A conditioner \(\Psi(t,\ell)\) maps step \(t\) and block index \(\ell\) to six scalars, \([\alpha_{\mathrm{pga}}, \beta_{\mathrm{pga}}, \alpha_{\mathrm{pcm}}, \beta_{\mathrm{pcm}}, n_{\mathrm{spec}}, \lambda]\), so early blocks at large \(t\) set global tone and late blocks at small \(t\) refine highlights.

Each MM-DiT block carries three adapters. Physically-Guided Adaptation, or PGA, adds a rank-8 LoRA residual to the frozen value projection of attention, gated per head and per token by the descriptors and scaled per head by the spectral bands.

\[ \begin{aligned} R_v^{t,\ell} &= \big(\alpha^{t,\ell}_{\mathrm{pga}} \mathbf{A}_v\mathbf{B}_v + \beta^{t,\ell}_{\mathrm{pga}} \mathbf{I}\big)\,\mathbf{G}_{\mathrm{phys}}\,\big(\mathbf{I} + n^{t,\ell}_{\mathrm{spec}} \mathrm{Diag}(g_{\mathrm{FFT}})\big) \\ \mathbf{W}_V &\leftarrow \mathbf{W}_V^{(0)} + R_v^{t,\ell} \end{aligned} \]

\(\mathbf{A}_v\mathbf{B}_v\) the low-rank pair, \(\mathbf{W}_V^{(0)}\) the frozen value weights, \(\mathbf{I}\) the identity, \(\mathbf{G}_{\mathrm{phys}}\) a diagonal gate that a sigmoid computes from \(T_{\mathrm{phys}}\) and \(g\), \(g_{\mathrm{FFT}}\) a positive gain per attention head computed from \(r\)

Perceptual Cross-Modulation, or PCM, is FiLM, a per-channel scale \(\gamma\) and shift \(\zeta\), predicted from the mean SigLIP token, applied to the layer-normalized hidden state \(\mathbf{h}^{\ell}\) and added back to it.

\[ \begin{aligned} {}[\gamma^{t,\ell}, \zeta^{t,\ell}] &= \alpha^{t,\ell}_{\mathrm{pcm}}\,\mathrm{MLP}\big(\overline{C_{\mathrm{perc}}(T_{\mathrm{perc}})}\big) + \beta^{t,\ell}_{\mathrm{pcm}} \\ \mathrm{PCM}(\mathbf{h}^{\ell}) &= \mathbf{h}^{\ell} + \gamma^{t,\ell} \odot \mathrm{LN}(\mathbf{h}^{\ell}) + \zeta^{t,\ell} \end{aligned} \]

\(\overline{\,\cdot\,}\) the mean over tokens, \(\mathrm{LN}\) layer normalization, \(\odot\) the elementwise product

The HDR Residual Coupler adds both paths to the block residual \(\mathbf{z}^{\ell}_{\mathrm{res}}\), with a weight \(\lambda^{\ell}_t\) that decays as \(t \to 0\).

\[ \mathbf{z}^{\ell}_{\mathrm{out}} = \mathbf{z}^{\ell}_{\mathrm{res}} + \lambda^{\ell}_t\big(W_p\,T_{\mathrm{phys}} + W_c\,\mathcal{R}\big(C_{\mathrm{perc}}(T_{\mathrm{perc}})\big)\big) \]

\(W_p\) and \(W_c\) learned projections into the residual width, \(\mathcal{R}\) a resampling of the SigLIP tokens to the latent grid

Sampling starts from the SDR latent instead of noise. The bridge sets \(z_1 = \mathcal{E}_{\mathrm{VAE}}(x_{\mathrm{sdr}}) + 0.05\,\mathbf{n}\), with \(\mathcal{E}_{\mathrm{VAE}}\) the frozen VAE encoder and \(\mathbf{n}\) standard Gaussian noise, and follows the predicted velocity from \(t = 1\) to \(t = 0\) in 8 solver steps. The frozen VAE decodes \(z_0\) and the result is converted to BT.2020 YUV. A small MLP on the pooled final latent fits a monotone rational-quadratic spline, a smooth increasing curve in 8 bins, to luma, and a 1 by 1 convolution maps chroma. The FLUX.1 VAE learned 8-bit SDR tones and its decoder bands when asked to expand range, so the spline carries the expansion and the DiT keeps the structure.

Training runs the same bridge on pairs[58]. With \(z_{\mathrm{hdr}}\) the latent of the HDR target and \(t\) drawn uniformly, the adapters see \(z_t = (1-t)\,z_{\mathrm{hdr}} + t\,z_1\) and regress the velocity \(z_1 - z_{\mathrm{hdr}}\) under a squared error, which is flow matching on a straight path. Every fourth step, a one-step estimate of \(z_0\) is decoded through the VAE and the spline, and the loss adds L1 terms on linear-light luminance and RGB and a smoothness penalty on neighboring knot slopes, weighted 1, 0.5 and 0.1.

Only 71.3M parameters train, 0.57 percent of the 12.48B loaded weights. The corpus holds 314,396 SDR/HDR pairs from 2,092 source videos. Its user-generated HDR comes from CHUG[31], whose 856 sources are a subset of Beyond8Bits[59], our HDR quality dataset, and the rest from LIVE-TMHDR, HDRTV1K[30] and Netflix's Sol Levante HDR10 master. Expert SDR grades exist only for LIVE-TMHDR, and HDRTV1K's 1,235 native pairs bring their own SDR. Every other SDR input is synthesized by eight tone-mapping operators, a gamut conversion and three levels of codec compression, against 1,000-nit targets. The main checkpoint took 100,000 steps on four GH200 GPUs, about 36 hours.

The table follows the synthetic track of the repository's Luma-Eval protocol, 100 held-out frames scored with identical inputs, encoding and metric code[58][60].‡ BT.2446c is Method C of ITU-R Report BT.2446[61], an HDR-to-SDR conversion, run here in the SDR-to-HDR direction with a fixed 1,000-nit peak, and the Reinhard inverse does the same with Reinhard's curve[24]. HDR-LPIPS is LPIPS, a learned perceptual distance, computed on PU21-encoded frames.

‡The arXiv v1 tables come from a different training corpus and a 40-step solver, so they do not compare with these. This post quotes only the protocol of the August 2026 public release.
MethodPU21-PSNR
(dB) ↑
PU21-SSIM ↑\(\Delta E_{\mathrm{ITP}}\) ↓HDR-LPIPS ↓HDR-VDP-3 ↑
BT.2446c inverse23.740.829161.600.3075.611
Reinhard inverse23.620.828661.760.2955.726
HDRTVNet++[43]23.030.819266.670.3285.417
FMNet[62]22.860.817667.920.3305.412
ITM-LUT[63]22.920.814267.410.3155.496
VAE + RQS, no diffusion18.540.7647111.670.3813.673
LumaFlux, 8 steps24.230.829456.540.2695.812

On PU21-PSNR, LumaFlux beats the best baseline, the BT.2446c inverse, by only 0.49 dB. The larger gains are in color and perception. The color difference \(\Delta E_{\mathrm{ITP}}\)[64] falls 8 percent against the same baseline, and HDR-LPIPS falls 8.8 percent against its best baseline, the Reinhard inverse. The VAE and the spline without the diffusion backbone lose 5.69 dB, so the DiT prior does most of the work.

Against other diffusion methods, the release uses the native track of Luma-Eval, 117 native SDR/HDR pairs, with cost normalized by output pixels at each method's registered protocol[58]. X2HDR trails LumaFlux by 4.9 dB at about six times the cost per output pixel.

MethodStepsPU21-PSNR (dB) ↑\(\Delta E_{\mathrm{ITP}}\) ↓s per megapixel ↓Trainable params ↓
LEDiff[11]5010.99198.5817.0860M
X2HDR[46]3018.6592.2016.2149M
LumaFlux823.5647.592.571M

The release computes \(\Delta E_{\mathrm{ITP}}\) as BT.2124 defines it, yet these values sit far above the 6 to 17 that HDRTV papers report on HDRTV1K and HDRTV4K. The test sets differ, so the two ranges do not compare. On HDRTV1K's 117 published test pairs, scored with our protocol on PQ-coded frames, our checkpoint trained on that set's training split scores 14.69, and the main checkpoint, whose mixed corpus also holds that split, scores 29.86. Published HDRTV1K baselines keep their own protocols and do not rank against these rows[58].

Checkpoint, trained onPSNR (dB) ↑SSIM ↑SR-SIM ↑\(\Delta E_{\mathrm{ITP}}\) ↓HDR-VDP-3 ↑
lumaflux-hdrtv1k, HDRTV1K training split33.340.94270.994114.697.962
lumaflux-main, mixed corpus27.520.93070.983729.867.618

The figure below sets LumaFlux beside the BT.2446c inverse and HDRTVNet++ on three frames from the test set.

SDR input
BT.2446c
HDRTVNet++
LumaFlux
Reference
City skyline at sunset with the sun behind the towers, SDR input, a box marks the crop region.
Sunset skyline, BT.2446c inverse.
Sunset skyline, HDRTVNet++.
Sunset skyline, LumaFlux.
Sunset skyline, HDR reference.
Crop around the sun and the towers, SDR input.
Crop around the sun and the towers, BT.2446c inverse.
Crop around the sun and the towers, HDRTVNet++.
Crop around the sun and the towers, LumaFlux.
Crop around the sun and the towers, HDR reference.
Pantheon dome seen from below with the oculus and the coffers, SDR input, a box marks the crop region.
Pantheon dome, BT.2446c inverse.
Pantheon dome, HDRTVNet++.
Pantheon dome, LumaFlux.
Pantheon dome, HDR reference.
Crop of the bright oculus and the coffers around it, SDR input.
Crop of the oculus and coffers, BT.2446c inverse.
Crop of the oculus and coffers, HDRTVNet++.
Crop of the oculus and coffers, LumaFlux.
Crop of the oculus and coffers, HDR reference.
Gorge with a river between dark rock walls, SDR input, a box marks the crop region.
River gorge, BT.2446c inverse.
River gorge, HDRTVNet++.
River gorge, LumaFlux.
River gorge, HDR reference.
Crop of the river and the rock walls, SDR input.
Crop of the river and the rock walls, BT.2446c inverse.
Crop of the river and the rock walls, HDRTVNet++.
Crop of the river and the rock walls, LumaFlux.
Crop of the river and the rock walls, HDR reference.
Three frames from the LumaFlux test set[51] expanded by the BT.2446c inverse[61], HDRTVNet++[43] and LumaFlux beside the HDR reference, each with a crop at identical coordinates under it. The HDR panels are SDR previews through one shared filmic tone curve.

In the night skyline pair below, the SDR input is dark and blocky, and the output resolves the boat's lamps and the sphere on the tower. The teaser has no ground-truth HDR panel, so the pair shows change and cannot show accuracy.

SDR crop of a night skyline across a river: a tower with a lit sphere and a passenger boat, dark and blocky.
SDR input
The same crop after LumaFlux, shown as an SDR preview, where the boat's lamps and the tower's sphere come through with more detail.
LumaFlux
The skyline crop from the LumaFlux teaser, before and after conversion[51]. Both panels are SDR previews from the repository, cropped from its teaser with no resampling. Source figure · Crop details.

Video runs through the same image model with no temporal layers or optical flow. One bridge-noise draw is shared by every frame, and an exponential moving average across frames smooths the spline parameters, never the pixels. Together they cut signed excess PU21 flicker by 53.3 percent, while pooled raw temporal energy stays within 3.3 percent of the reference, so the cut does not come from flattening motion. A 1080p frame takes 5.28 s on one GH200, against 0.367 to 0.857 s for CNN converters.

The release also measures a slight oversaturation, with mean ITP chroma at 60.65 against 49.80 for the references. The frozen VAE still decodes 8-bit SDR tones, so all range expansion rests on the spline, and the spline cannot invent detail that heavy clipping erased from the SDR input. Temporal stabilization runs only at inference, with no long-range motion model, and no controlled subjective study exists yet. The images in this section are SDR previews from the repository, so none of them shows the PQ range the model writes.

LumaGuide

LumaGuide changes no weight and steers a text-to-image model that never saw HDR[4]. The sampler pulls the PQ luminance histogram of the output toward a 32-bin target \(\mathbf h^\star\), taken from a preset HDR profile, from the PQ histogram of a reference image, or from the prompt. The release runs on FLUX.1-dev, a 12B-parameter rectified-flow transformer, and the paper adds SD3-medium at 2B and SDXL at 3.5B. The decoded RGB is clamped to \([0,1]\) and read as PQ code values, so 1.0 means 10,000 nits.

At every step the frozen transformer predicts a velocity, the frozen VAE decoder turns the one-step estimate of the finished latent into pixels, and the BT.2020 luminance weights reduce those PQ-coded pixels to one channel:

\[ \hat x_0 = \mathrm{Dec}\big(z_t - t\,v_\theta(z_t,t)\big), \qquad Y = 0.2627R + 0.6780G + 0.0593B \]

\(z_t\) the latent at time \(t\), \(v_\theta\) the predicted velocity, \(\mathrm{Dec}\) the VAE decoder, \(R,G,B\) the PQ-coded channels of \(\hat x_0\), \(Y \in [0,1]^{H\times W}\)

The release code reads the decoded channels as PQ and takes this weighted sum directly[65]. A Gaussian soft histogram keeps the binning differentiable. The energy is the Wasserstein-1 distance \(W_1\) between the two histograms, the least distance that mass has to travel along the luminance axis to turn one into the other, which on an ordered bin grid is a sum over the cumulative histograms:

\[ \begin{aligned} h_k &= \frac{1}{N}\sum_{i=1}^{N} \frac{1}{Z_i}\exp\!\Big(-\frac{(Y_i-b_k)^2}{2\sigma^2}\Big) \\ E &= W_1(\mathbf h,\mathbf h^\star) = \sum_{k=1}^{K-1} \big|H_k - H^\star_k\big| \end{aligned} \]

\(b_k\) the \(K = 32\) bin centers, \(\sigma = 0.5/K\), \(N = HW\) pixels, \(Z_i\) the factor that makes pixel \(i\)'s bin weights sum to one, \(H_k = \sum_{j \le k} h_j\) and \(H^\star_k\) the cumulative histograms, with distance counted in bins as the release code does

The paper also damps each bin with a "perceptual-log" weight on the PQ-to-nits gradient[4]. The gradient of \(E\) reaches the latent through the decoder and the luminance map only, and shifts the velocity before the solver step:

\[ v_{\mathrm{guided}}(z_t,t) = v_\theta(z_t,t) + s(t)\,\nabla_{z_t} E, \qquad \nabla_{z_t} E = \frac{\partial E}{\partial \hat x_0}\,\frac{\partial \hat x_0}{\partial z_t} \]

\(s(t) = s_0\) held constant, 2000 for FLUX.1-dev at 512 by 512, 1000 for SD3 and 50 for SDXL, over 28 steps with a classifier-free guidance scale of 3.5

The sampler steps \(z \leftarrow z - \Delta t\, v\) toward \(t = 0\), so adding the gradient to the velocity moves the latent downhill on \(E\). The paper times one image at 7.8 s for 512 by 512 and 32.3 s for 1024 by 1024 on one A100[4], and the README puts memory at about 30 GB for the smaller size[65].

gradient Prompt Denoiser step FLUX.1 or CogVideoX latent Decode HDR Histogram regressor target current W₁ frozen guidance
At each sampling step the current estimate is decoded, its PQ luminance histogram is compared with the target by a Wasserstein-1 distance, and the gradient shifts the latent while every generator weight stays fixed[4]. The two histograms are schematic, and the target can also be a preset or a reference image.

The paper scores the gap to the target as uW1, the unweighted \(W_1\) between the output's PQ luminance histogram and \(\mathbf h^\star\) over 32 bins. The release code counts that distance in bins[65], so the unguided 3.79 is 3.79 bins, about 0.12 of the PQ axis. In the paper's domain and distance ablation[4], a histogram taken in linear light leaves uW1 at 3.73 with \(W_1\) and 3.79 with L2, so guidance does nothing. In PQ, L2 reaches 3.40, KL divergence 2.06 and \(W_1\) 0.58. KL and L2 compare bins one at a time, while the gradient of \(W_1\) shifts mass into neighboring bins.

The text route is a regressor of about 270K parameters. It passes the text features of a frozen CLIP ViT-L/14 through an MLP of 768, 256, 256 and 32 units with GELU and a softmax. We fit it with a KL loss on about 24,000 frames from Beyond8Bits[1], four per video, each captioned for content, lighting and materials by Qwen2.5-VL-7B, so the targets it predicts are histograms of real user-generated HDR. The paper's regressor appendix[4] reports a test KL of 0.346 on a video-level split.

In the paper's guidance-scale table[4], raising \(s_0\) from 0 to 2000 lowers uW1 from 3.79 to 0.58 and the 99th-percentile luminance from 4,867 to 1,694 nits. Read as PQ, unguided FLUX.1 output already sits that bright at the top, and guidance moves the excess mass into the mid-tones. Past 2000 the return stops, and above about 3000 the images band and textures turn unnatural. The row at \(s_0 = 0\) is unguided FLUX.1, and the p50 and p99 gaps are the absolute errors of those luminance percentiles against the target, in PQ units.

\(s_0\)uW1 ↓p50 gap ↓p99 gap ↓p99 luminance (nits)
03.790.1160.2074,867
103.770.1150.2064,861
1003.420.1040.1984,658
5002.160.0710.1533,558
10001.250.0450.1052,648
20000.580.0240.0531,694
30000.490.0200.0411,425
50000.520.0190.0451,496

All quantitative numbers use 100 HDR-oriented prompts at 512 by 512. In the subjective study, 15 observers ranked LEDiff[11], Bracket Diffusion[47], X2HDR[46] and LumaGuide on consumer HDR displays. We scaled the 600 four-way rankings to JOD. In the paper's subjective-study tables[4], LumaGuide scored +0.75 JOD, with a 95 percent interval of +0.65 to +0.85, against +0.43 for X2HDR, which fine-tunes its backbone, and ranked first in 50.2 percent of trials against 32.0 percent. The paper's baseline comparison[4] adds dynamic range, the log2 ratio of the 99.5th to the 0.5th percentile of linear luminance, and Q-Eval[66], a scorer trained on human ratings of SDR generated images, with separate quality and prompt-alignment scores.

MethodQ-quality ↑Q-alignment ↑Range (stops) ↑JOD ↑Time ↓
LEDiff0.4250.6124.71−0.88∼8.6 s
Bracket Diffusion0.4480.64812.25−0.30∼389 s
X2HDR0.5790.77311.41+0.43∼6 s
LumaGuide0.5680.81414.99+0.757.8 s

The quality score went the wrong way for us, 0.568 for LumaGuide against 0.579 for X2HDR. The protocol, borrowed from X2HDR, feeds Q-Eval PQ-encoded 8-bit outputs without tone mapping, and its quality score generally falls as guidance grows, even in the moderate range where the images look more HDR. In the panels below, plain FLUX.1 clips the spotlight to a flat plateau, and LumaGuide keeps a sloped highlight and lifts the dress.

For video on CogVideoX-5B, the energy sums the per-frame \(W_1\) and adds a temporal luminance coherence term, TLC, that penalizes frame-to-frame change on bright pixels:

\[ E_{\mathrm{video}} = \sum_{\tau=1}^{T} W_1(\mathbf h_\tau,\mathbf h^\star) + \lambda_{\mathrm{TLC}} \sum_{\tau=2}^{T} \big\|(Y_\tau - Y_{\tau-1}) \odot \Omega_\tau\big\|_2^2 \]

\(Y_\tau\) the PQ luminance of frame \(\tau\), \(\Omega_\tau\) a high-luminance mask whose threshold the paper does not state, \(\odot\) the elementwise product, \(\lambda_{\mathrm{TLC}}\) the weight of the temporal term

In the paper's CogVideoX table[4], over 30 prompts of 33 frames, the temporal variance of PQ luminance in highlights, pixels above PQ 0.6, falls from 0.033 unguided to 0.016 with TLC. The score has no motion compensation.

CogVideoX-5BuW1 ↓p50 gap ↓p99 gap ↓Highlight variance ↓
Unguided6.85 ± 2.830.2500.2450.033
+ \(W_1\) guidance4.03 ± 3.080.1590.1550.025
+ \(W_1\) + TLC3.98 ± 3.120.1600.1540.016

In the strip below, the plain model washes the sunlit waterfall to white by the third frame, and both guided rows keep rock and water structure.

Three rows of three frames for two prompts, a sunlit waterfall and a cathedral with stained glass: CogVideoX vanilla, W1 guidance, and W1 guidance plus TLC. The vanilla waterfall washes to white by the third frame, and the guided rows keep rock and water structure.
Three frames from each of two CogVideoX-5B prompts, a sunlit waterfall and a cathedral with stained glass, sampled plain, with W1 guidance, and with W1 guidance plus TLC[4]. The strip is an SDR preview from the repository. Source figure.

Pixels clamped at PQ 1.0 pass no gradient back through the decoder, so guidance cannot pull them down. A larger \(s_0\) darkens their surroundings instead, which leaves halos, exaggerated contrast and residual p99 error. Indoor and low-contrast prompts cannot reach an HDR target at all, and the sampler settles on a compromise, because the prior decides which histograms are reachable. Finer bins hurt as well. In the paper's bin-count table[4], Q-Eval quality falls from 0.568 at \(K = 32\) to 0.533 at 64 and 0.371 at 256. uW1 goes from 0.576 to 0.908 and 4.734, each counted in its own bins.

The histogram is permutation-invariant. It fixes which luminances appear and in what proportions, and says nothing about where, so a matched histogram cannot tell us whether the highlights sit on the right objects. The public code covers text-to-image on FLUX.1-dev only, and the README lists the SD3, SDXL and CogVideoX hooks, TLC included, as pending[65].

Video adds flicker

Chen et al.[30] named the video version of ITM SDRTV-to-HDRTV. The input is an 8-bit SDR frame, the target is an HDR10 frame in PQ and BT.2020, and the network writes 10 to 16 bits per channel, saved as 16-bit PNG. They treat an SDR broadcast as the output of a formation pipeline of tone mapping, gamut mapping, the OETF and quantization, and train a network to run that pipeline backwards.

HDRTV1K[30] is the set nearly every later paper reports on. It starts from 22 HDR10 videos taken from YouTube, 18 for training and 4 for testing. One frame every two seconds gives 1,235 training frames, and 117 frames without repeated scenes form the test set, all at 4K. The SDR half of each pair is YouTube's own automatic down-conversion, a convention borrowed from Deep SR-ITM[10], so the mapping a model learns is whatever YouTube's tone mapper did. Guo et al. built HDRTV4K[32] to get away from that.

HDRTVNet splits the inverse into three stages

Adaptive global color mapping (AGCM) comes first. Its base network is three 1 by 1 convolutions with 64 channels, so every pixel is mapped independently and the stage behaves like a 3D lookup table from input RGB triple to output triple. A condition network reads a frame downsampled by 4 and emits a 6-dimensional vector that scales and shifts the base features. AGCM has 35K parameters and matches Ada-3DLUT with 1/17 of its parameters. Local enhancement (LE) follows with a stride-2 convolution, 16 residual blocks at 64 channels and a pixel-shuffle upsampler, for 1.41M parameters across both stages. Both train with an L2 loss.

Highlight generation (HG) is a GAN with an encoder-decoder generator \(G\) and a VGG-style discriminator. Its output is \(\hat I = I_{\text{mask}} \odot G(I) + I\), where \(I\) is the frame entering the stage, \(I_{\text{mask}}\) marks the highlight regions and \(\odot\) is the elementwise product, so the generator adds content only inside the mask. The full model has 37.20M parameters.

The paper's own Table 1 shows the third stage hurting four of five metrics. Adding HG's 35.79M parameters lowered PSNR from 37.61 to 37.21 dB and HDR-VDP-3 from 8.613 to 8.569. SSIM and \(\Delta E_{\mathrm{ITP}}\), a color difference, got worse too. The GAN stage won only SR-SIM, a structural similarity index, 0.9968 against 0.9967. HDRTVNet++[43] later renamed the stage "highlight refinement" and reused AGCM+LE as its generator.

Six years of methods moved PSNR by 1.5 dB

Every method in the chart reports PSNR on the 117 HDRTV1K test frames. HDRTVNet computes it on the PQ-encoded frames. From Deep SR-ITM at 37.10 dB to the jointly fine-tuned HDRTVNet++ at 38.60 dB, PSNR rose 1.50 dB. HDR-VDP-3 rose from 8.233 to 8.751 for the full HDRTVNet++ pipeline. Model size fell from 2.87M to 591K parameters. Nothing in the chart since HDRTVNet's AGCM+LE at 37.61 dB beats it by a full decibel.

Deep SR-ITM2019 37.10 JSI-GAN2020 37.01 HDRTVNet2021 37.61 FMNet2022 37.94 HDRTVDM2023 37.98 HDRTVNet++2024 38.60 PSNR, dB (higher is better)
PSNR on the 117-frame HDRTV1K test set[30] as each source reports it, with HDRTVNet plotted as AGCM+LE and HDRTVNet++[43] as the jointly fine-tuned AGCM-LE++. Chen et al. retrained Deep SR-ITM[10] and JSI-GAN and re-ran HDRTVDM[32], and FMNet[62] reports its own row.

Check who produced a number before trusting it. Chen et al. retrained Deep SR-ITM and JSI-GAN on HDRTV1K without their super-resolution branches, so their Deep SR-ITM has 2.87M parameters against the original's 2.5M at 2x upscaling. Pixel2Pixel, CycleGAN, HDRNet, CSRNet and Ada-3DLUT in the same table are also their retrainings. HDRTVDM's 37.98 dB is a re-run in HDRTVNet++. FMNet[62] reports its own row.

Metric settings move these numbers as much as methods do. The HDRTVDM checkpoint in Guo et al.'s README scores HDR-VDP-3 9.0997 under Guo's own settings against 8.610 in the HDRTVNet++ re-run, a 0.49 shift about the size of the whole six-year gain. Our LumaFlux release[51] scores the 117 test pairs with its own protocol on PQ-coded frames. Its in-domain checkpoint reaches 33.34 dB and its main checkpoint, whose mixed corpus includes the HDRTV1K training frames, 27.52 dB. Its evaluation notes call the published baselines, each run under its own settings, "not directly rankable" against those numbers, so we leave LumaFlux off the chart.

Why per-frame expansion flickers

Every number in that benchmark scores one frame at a time, and none of them sees what happens between frames. Lai et al. state the general case: "Applying image-based algorithms independently to each video frame typically leads to temporal flickering due to the instability of global optimization algorithms or highly non-linear deep networks."[67] Tedla et al. find "severe temporal flickering and exposure drift" in frame-wise image priors[54]. Two mechanisms follow. A global mapping such as exposure, a tone curve or HDRTVNet's color condition vector is re-estimated per frame and jitters with content. A GAN or diffusion stage draws an independent sample per frame, so a hallucinated highlight changes texture from frame to frame.

The standard flicker measure from video processing is the warping error of Lai et al., which WMNet reports for video ITM:

\[ \begin{aligned} E_{\mathrm{warp}}(V_t, V_{t+1}) \;&=\; \frac{1}{\sum_{i=1}^{N} M_t^{(i)}} \sum_{i=1}^{N} M_t^{(i)} \left\| V_t^{(i)} - \hat{V}_{t+1}^{(i)} \right\|_2^2, \\ E_{\mathrm{warp}}(V) \;&=\; \frac{1}{T-1} \sum_{t=1}^{T-1} E_{\mathrm{warp}}(V_t, V_{t+1}) \end{aligned} \]

Here \(V_t^{(i)}\) is pixel \(i\) of output frame \(t\), \(\hat{V}_{t+1}\) is frame \(t+1\) warped back to frame \(t\) by optical flow, \(M_t^{(i)} \in \{0,1\}\) is the non-occlusion mask of Ruder et al., \(\|\cdot\|_2^2\) is the squared difference summed over color channels, \(N\) is the pixel count and \(T\) the frame count. Lower is steadier, which rewards doing nothing. On the HDRTV4K-Scene clips, WMNet scores 0.01392 and HDRTVNet 0.01394, while the classic expansion operator of Kovaleski and Oliveira scores 0.01035 because it barely changes the frame[68]. Read it next to a fidelity score.

Two ways to hold a highlight still

Ye et al. align and propagate[69]. Every sixth frame is a keyframe that gathers six clues in each direction at stride 15, from frames up to 90 away, through a "flow correction convolution" that aligns frames of different luminance. Features then propagate both ways to the frames between. In their ablation HDR-VQM[70], a video metric that pools perceptual error over short spatio-temporal tubes and scores lower for better video, falls from 0.383 without the module to 0.376 with plain warping and 0.356 with the full module. Running the clue module on keyframes only costs 521 ms per 512 by 512 frame on a V100, against 1,236 ms on every frame.

The other route acts at sampling time with no video training. LumaGuide adds its TLC term to the guidance energy on CogVideoX-5B[4]. LumaFlux, an image model run per frame, shares one noise realization across frames and smooths its tone-curve parameters over time[51]. Neither is motion compensated, so both lower flicker on static content and prove nothing about a highlight that moves.

Cost is reported on different GPUs and resolutions, so the table gives the conditions beside each number.

MethodParametersTimeConditions
ITM-LUT[63]452K + 221K LUT entries0.254 sone UHD frame, A2000 12 GB
HDRTVNet[30]37.20M2.235 sone UHD frame, A2000, timed by ITM-LUT
FMNet[62]1.24M2.635 sone UHD frame, A2000, timed by ITM-LUT
Ye et al. (video)not reported521 msone 512 by 512 frame, V100
LumaFlux (diffusion, per frame)71.3M trainable (LoRA on FLUX.1-dev)5.3 s, 27 GBone 1080p frame, 8 steps, GH200
LumiVid (video DiT)rank-128 LoRA on LTX-2.529.5 s, 22.1 GB17 frames at 1280 by 704, GPU unstated, timed by Tedla et al.

Video diffusion models that emit HDR

Three 2026 papers fine-tune a pretrained video generator into an SDR-to-HDR converter. All three leave the video VAE as released, so the HDR target is either re-encoded into the range SDR latents already cover or predicted as SDR-like exposure brackets and merged outside the model. Their configurations are the closest thing to a video fine-tuning recipe.

  • DiffHDR[48]: a rank-32 LoRA on the attention and feed-forward layers of Wan-2.1-VACE-14B. The target is linear radiance passed through a log-gamma curve. Training runs 10,000 steps on eight A100s over about 5,400 sequences of 81 frames rendered from about 800 Poly Haven panoramas.
  • LumiVid[49]: a rank-128 LoRA on LTX-2.5, with scene-linear HDR encoded by the ACEScct camera log curve. A flow-matching loss on the HDR tokens runs 5,000 steps, about eight hours on one A100, over about 300 synthetic clips of 49 frames, with degradations applied to the SDR input. Inference takes 8 steps at 720 by 1280.
  • Tedla et al.[54]: every transformer weight of Wan2.2-I2V-5B, trained with flow matching to predict three exposures at −4, 0 and +4 EV for 17-frame clips. A learned per-pixel merge of about 5K parameters blends them into linear HDR. The data are 11,336 clips cut from 26 HdM-HDR videos shot at Stuttgart Media University, with SDR inputs synthesized by noise, a random camera response curve, clipping and 8-bit quantization.

Temporal consistency comes from the backbone's own attention. LumiVid gives SDR and HDR tokens the same 3D rotary position embedding, so the HDR tokens attend to the SDR clip through the DiT's self-attention. Tedla et al. stack the exposures along the frame axis with a learned exposure-aware position offset. On 50 ARRI clips of 49 frames, LumiVid's frame-to-frame PU21-PSNR, where higher is steadier, is 54.28 against 44.81 for HDRTVNet++[43], and its frame-to-frame LPIPS of 0.0059 is slightly worse than the 0.0057 of HDRTVNet++.

HDR from commercial video generators

Lightricks, Luma AI and Runway now ship HDR video output, and of the three only Lightricks ties its product to a paper. Lightricks released an HDR IC-LoRA for LTX-2.3 on April 15, 2026. The release notes say it generates HDR from text or an image and also converts SDR video, writes scene-linear float16 EXR, and rests on LumiVid[71]. LumiVid's v2 describes the method on LTX-2.5 with ACEScct[49]. LTX-2.5, released August 11, 2026, reads and writes EXR[71].

Luma AI announced Ray3 on September 18, 2025, calling it the first model to output 10-, 12- and 16-bit HDR in ACES2065-1 EXR, and said it also turns SDR video into HDR[72].

Runway added two routes on August 20, 2026. Gen-4.5 can deliver HDR10, HLG, ProRes and EXR, which the changelog calls "true HDR renders"[73]. The same entry says that output is graded into BT.2020 with measured HDR10 metadata. Ruby converts SDR clips of up to 30 seconds and under 4,096 pixels per side, rejects HDR input, and returns HDR10 as 10-bit HEVC, HLG, PQ ProRes, or 16-bit half-float EXR in linear BT.2020. Runway says Ruby keeps the source pixels and re-synthesizes nothing[73]. Runway has published no method for either model. Beeble's SwitchHDR, released July 3, 2026, is another converter. It writes 16-bit scene-linear ACES2065-1 EXR, and on training Beeble says only that it used real HDR footage[74].

In this post's terms, the LTX adapter sits with LumiVid under directions A and D, and Ruby, SwitchHDR and the SDR conversion modes of LTX and Ray3 are ITM. Ray3 and Gen-4.5 generate HDR natively by their makers' account, and neither maker has said how.

SystemReleaseHDR outputRoute, per vendorMethod published
LTX-2.3 HDR IC-LoRA[71]Apr 15, 2026float16 scene-linear EXRGeneration and SDR conversionLumiVid paper
Luma Ray3[72]Sep 18, 202510-, 12- and 16-bit ACES2065-1 EXRGeneration and SDR conversionNo
Runway Gen-4.5[73]Aug 20, 2026HDR10, HLG, ProRes, EXRGenerationNo
Runway Ruby[73]Aug 20, 2026HDR10, HLG, PQ ProRes, 16-bit EXRSDR conversionNo
Beeble SwitchHDR[74]Jul 3, 202616-bit ACES2065-1 EXRSDR conversionTraining data type only

Getting HDR frames onto a television

A generated HDR video reaches a screen in one of four formats. HDR10 adds static metadata to 10-bit PQ in BT.2020 4:2:0, an ST 2086 record of the mastering display[23] and two content light levels in nits. MaxCLL is the brightest pixel in the stream and MaxFALL is the brightest frame average. HDR10+ and Dolby Vision add tone-mapping metadata per scene or per frame. HLG, standardized as ARIB STD-B67, is scene-referred and keeps "a degree of compatibility with legacy displays"[21]. ITU-R Report BT.2408 puts HDR reference white at 203 nits, on a PQ display or on an HLG display with a 1,000-nit peak[75], so SDR white mapped to 100 nits sits about one stop below the HDR reference.

DiffHDR, LumiVid, Tedla et al. and X2HDR[46] emit linear radiance or PU21 values, so each still needs a PQ or HLG transfer, a chosen mastering peak, the BT.2020 and transfer flags in the bitstream and, for HDR10, the metadata above before a television treats the stream as HDR. LumaFlux writes 10-bit PQ BT.2020 directly, which leaves only the flags and metadata. LumaGuide's release saves linear Radiance .hdr files, so it needs the PQ transfer as well.

Measuring what you cannot show

Every HDR score assumes a display.

HDR-VDP scores light, in two units

HDR-VDP[76] extends Daly's Visible Differences Predictor to the full luminance range. A display model turns pixels into emitted light in nits. Optical and photoreceptor stages add glare and local adaptation. A multi-band contrast masking and sensitivity model then predicts which differences the eye can detect. HDR-VDP-2 pools those differences into a quality score \(Q\) and maps it to 0 to 100 with a logistic fitted to the LIVE image-quality database, where 100 means no predicted difference.

HDR-VDP-3[77] refits the contrast sensitivity function to newer data, adds age effects and side-by-side and flicker tasks, and reports quality in just-objectionable differences, or JOD. A perfect match scores 10, and a drop of 1 JOD is a degradation that 75 percent of observers notice. A score of 8.28 therefore sits 1.72 JOD below a perfect match, on a different axis from \(Q\).

Both versions expect nits, because glare, adaptation and sensitivity depend on retinal illuminance. PQ codes or 0 to 1 floats fed without a display model change the assumed luminance and with it the score, and so does the assumed screen. SingleHDR reports 53.16 \(Q\) for itself on the 46 HDR-Eye images and states no display settings[42]. ExpoCM re-measures it at 45.23 on 46 pairs resized to 512 by 512 at 30 pixels per degree[50]. HDRTVNet states its settings in full, as every HDR-VDP number should: the side-by-side task, rgb-bt.2020 color encoding, 50 pixels per degree and an led-lcd-wcg display[30].

PU21 puts HDR on an 8-bit scale

PSNR, SSIM and LPIPS on linear radiance weight bright pixels far more than the eye does. A perceptually uniform (PU) encoding maps luminance to values on which those SDR metrics behave as they do on 8-bit sRGB. PU21[78], the 2021 successor to PU08, builds its curve from a contrast sensitivity model fitted to measurements up to 10,000 nits, adds models of banding and glare, and fits the result with one invertible equation.

\[ V = \max\!\left( p_7 \left[ \left( \frac{p_1 + p_2 L^{p_4}}{1 + p_3 L^{p_4}} \right)^{p_5} - p_6 \right],\; 0 \right) \]

\(L\) absolute luminance in nits, valid from 0.005 to 10,000, \(V\) the PU21 value, and \(p_1\) to \(p_7\) fitted coefficients

PU21 has four variants. Banding variants model the visibility of a quantized smooth gradient, the artifact 10-bit coding produces. Peaks variants use the peak of the contrast sensitivity function, as PQ and PU08 do. Glare variants lower sensitivity next to bright pixels. The banding_glare variant is the default because it correlated best with subjective judgments, and its coefficients are \(p_1 = 0.353487901\), \(p_2 = 0.3734658629\), \(p_3 = 8.277049286 \times 10^{-5}\), \(p_4 = 0.9062562627\), \(p_5 = 0.09150303166\), \(p_6 = 0.9099517204\), \(p_7 = 596.3148142\). The curve is rescaled so that 0.1 to 100 nits, the range of a typical SDR display, spans about 256 values, and 100 nits lands near 256. PU-PSNR therefore uses a peak of 256.

X2HDR[46], LumiVid[49] and LumaFlux[51] report PU21 scores. The encoder takes absolute luminance, so each had to pick a peak for relative outputs, and the pick moves the number.§ The chart below shows where PU21, PQ and log luminance spend their values, the weighting any PSNR computed on them inherits. PU21 rises more slowly than PQ below about 4 nits and faster above, so a PSNR on PQ codes weights errors in the darks more than the same PSNR on PU21 values.

§X2HDR trains against a log-quadratic approximation with its own coefficients. It is a different function from this encoder, so do not mix the two.
0.01110010,00000.51luminance (nits, log scale)encoded value (rescaled) PQPU21
PU21 in its banding and glare variant[78] and the PQ inverse EOTF[7], each rescaled to run from 0 to 1 over 0.005 to 10,000 nits, with log10 luminance as the dashed diagonal and 100 nits marked. Per decade of luminance PU21 rises at 0.80 times the PQ slope at 1 nit, 1.07 times at 100 nits and 1.16 times at 1,000.

PSNR depends on where it is computed

The HDRTV1K protocol takes PSNR on PQ codes. PQ is a fit to a contrast-sensitivity threshold curve, so equal code steps are close to equally visible only on a display that reaches the PQ peak, viewed in the dark. A 1,000-nit display never shows codes above 0.752, yet PSNR still rewards agreement on the top quarter of the code range.

On linear light, a 10 percent error at 4,000 nits carries 1,600 times the squared error of a 10 percent error at 100 nits. HDRCNN trains in the log domain so that "perceived errors spread approximately uniformly across the luminance range"[38]. On a tone-mapped preview the operator joins the system under test. Hanji et al. found metrics "highly sensitive to shifts in tone and color due to incorrect camera response function (CRF) estimation," while artifacts objectionable to humans in saturated regions moved the scores less[3].

The NTIRE 2021 HDR challenge ranks entries by PSNR after the mu-law, a logarithmic compression of the normalized image[34].

\[ \tau(H) = \frac{\log(1 + \mu H)}{\log(1 + \mu)}, \qquad \mu = 5000 \]

\(H\) the HDR image normalized to \([0, 1]\) by the ground-truth peak, \(\mu\) the compression strength, and mu-PSNR the PSNR between \(\tau(H_{\mathrm{pred}})\) and \(\tau(H_{\mathrm{gt}})\)

Every entrant can reproduce it bit-exactly, it needs no display model or viewing distance, and it compresses highlights so the score stops being a highlight score. It also describes no real display.

Color difference and the rest

\(\Delta E_{\mathrm{ITP}}\)[64], from ITU-R BT.2124, converts both images to ICtCp, the BT.2100 encoding with an intensity channel \(I\) and two chroma channels \(C_T\) and \(C_P\). It sets \(T = 0.5\,C_T\) and \(P = C_P\) and takes \(720\sqrt{\Delta I^2 + \Delta T^2 + \Delta P^2}\) per pixel, with \(\Delta\) the difference between the two images in each channel. The factor 720 makes 1 a just-noticeable difference for the most sensitive state of adaptation, so the metric may over-predict visibility. HDRTV papers report values from 6 to 17. The rest, one line each:

  • SR-SIM[79]: an SDR similarity index that HDRTVNet runs on PQ frames.
  • HDR-VQM[70]: full-reference HDR video error pooled over spatio-temporal tubes of 15 frames.
  • FID on tone-mapped outputs: LEDiff's highlight FID-L is 13.73 against 16.67 for HDRCNN[11], but the tone mapper and the Inception features are both SDR, so it misses compressed highlights.
  • Warping error[67]: the flicker measure the video section defines.

Observers, and the screen the reader does not have

HDR-VDP-3's quality task was recalibrated on UPIQ, a set of over 4,000 SDR and HDR images scaled in JOD by observers[77]. Those JODs come from pairwise comparison. An observer sees two conditions on a calibrated HDR display and picks the better one. Scaling software turns the win matrix, the count of how often each condition beat each other one, into JODs by maximum likelihood under Thurstone's case V model. The model treats each condition's perceived quality as a Gaussian with a shared variance, and a Bayesian prior keeps unanimous pairs finite. The scale is relative, so one condition, usually the SDR input, is pinned at 0 and positive JODs mean improvement. Measured and predicted JODs share a unit, so a paper can put both in one table.

Generation needs these judgments more than reconstruction does. A text-to-HDR sample has no ground truth, and an SDR-to-HDR sample has one capture among many plausible fillings of the clipped region, so a full-reference metric penalizes every plausible answer the camera did not record. Hanji et al. already write that "most image quality metrics are more suitable for the assessment of the restoration task rather than the enhancement task," and their study scored each method against the SDR input it started from[3].

That study, SI-HDR, tested ExpandNet, HDRCNN, MaskHDR, SingleHDR, DrTMO and HDR-GAN on 27 HDR images with 14 observers[3]. Two of the six "are more likely to decrease quality than improve it." Every metric tested correlated poorly with the measured JODs, among them HDR-VDP-2, HDR-VDP-3, the foveated video metric FovVideoVDP and SDR metrics run through PU21 or the mu-law. Among ITM papers, HDRCNN ran its study on a projector-based display with a 5,000-nit peak and a 0.1-nit black[38], HDRTVNet on a 1,300-nit Sony X9500G in a dark room[30], and LEDiff reports 84.19 percent preference over HDRCNN[11]. Most other methods in the HDR-Eye and HDRTV1K benchmark charts report metrics only.

We have built the no-reference side for HDR video, which scores a video with no pristine reference. HIDRO-VQA[80] transfers SDR quality features to HDR with contrastive self-supervision on unlabeled HDR video. CHUG[31] holds 856 user-generated HDR sources, 5,992 transcoded videos and 211,848 crowd ratings. BrightRate[81] adds the BrightVQ dataset of 300 sources, 2,100 clips and 73,794 ratings, and a model that regresses HDR luminance, semantic and temporal-difference features to mean opinion score. Beyond8Bits[1] has 6,861 sources, about 44,276 clips and over 1.5M ratings, and its model HDR-Q, a multimodal LLM that reads native 10-bit PQ, reaches a Spearman correlation of 0.9206 against 0.8914 for its SDR variant. Challenges of HDR covers this work.

A page can still show the SDR input next to the HDR output at minus 2, 0 and plus 2 stops of exposure, a false-color luminance map with a nit scale, and numbers with their display model stated. The web now has routes for the real file. Legacy readers show the SDR base of an Ultra HDR JPEG, and supporting readers scale its gain map by the display's headroom, so one file serves a 1.5x and a 4x display[55]. The (dynamic-range: high) media query lets a page send the HDR file only to displays that report HDR, and the SDR preview to the rest.

Honest edges

Every image in this post is SDR, an SDR input, an SDR rendering of an HDR frame or an SDR preview of an HDR result, so no reader sees the range the models write. PQ code 1.0 stands for 10,000 nits, and the sRGB reference display that web images assume puts white at 80 nits[7][20]. HDRTVNet ships its figures as 16-bit PNGs of PQ code values and warns they "may look relatively darker than on HDR" screens[30]. Our LumaGuide user study needed consumer HDR displays, 10-bit files in AVIF, a still-image format built on the AV1 video codec, and every image scaled so its 99.5th-percentile luminance sat at 4,000 nits[4].

ITM has no shared benchmark. On the 117 HDRTV1K test frames, our in-domain LumaFlux checkpoint scores 33.34 dB, and our release's evaluation notes call the published baselines, each run under its own protocol, "not directly rankable" against it[51]. HDRTV4K is missing from our results because we could not obtain its ground truth through an open channel[32][51]. On the generative side, LEDiff tests on a held-out SI-HDR subset and X2HDR on 96 SI-HDR RAW images, and the two report different metrics[11][46]. Text-to-HDR has no accepted metric at all, and the Q-Eval scorer it borrows learned from SDR images[4].

Where the SDR input clipped, every method invents content. Banterle et al. found that once more than 30 percent of an image is over-exposed, the expand map yields "a smooth gray gradient pattern, because there is not enough information"[35]. HDRCNN's users found "the artificial texture of the sun is immediately obvious"[38], and X2HDR reports that extreme under- or over-exposure "still yields implausible hallucinations"[46]. Across the generative papers, hallucinated detail raises no-reference scores and user preference while HDR-VDP falls, which is why GlowGAN calls full-reference metrics "not well suited" to the task[45].

The large HDR video sets, CHUG, BrightVQ and Beyond8Bits, are display-referred HDR10 with no graded SDR partner[31][81][1], and their clip counts include transcodes. The Beyond8Bits paper counts about 44,276 clips from 6,861 sources, and its public release lists 41,419 clips, which are 5,917 sources and six transcodes of each[59].

Running the LumaFlux bridge for 40 steps instead of 8 cost 4.7 times more and gave no quality gain[51]. In LumaGuide, going from 32 to 256 histogram bins dropped Q-Eval quality from 0.568 to 0.371, and a dual histogram that weights the bright bins harder dropped it to 0.325[4].

What to try first

Pick the route by what you hold. Each ends in a PQ or linear-light file that still needs a container and metadata before a screen shows it as HDR.

A starting point for each input

  • SDR photo. Run a learned ITM and keep the BT.2446c inverse as the floor it has to clear. On Luma-Eval that floor sits 0.49 dB PU21-PSNR below LumaFlux[51].
  • SDR video. A feed-forward CNN converter takes 0.367 to 0.857 s per frame, against 5.28 s per 1080p frame for LumaFlux on one GH200. LumaFlux holds up better on compressed sources, losing 0.55 dB across a sweep of the codec's quantization parameter from 27 to 42 on HDRTV1K where HDRTVNet++ loses 2.77 dB[51]. Measure the warping error on PU21-encoded frames[67] before trusting a per-frame result.
  • Text prompt, weights frozen. Run LumaGuide on FLUX.1-dev with the four guidance steps below[4].
  • Text prompt, a few GPUs to spare. Train a PU21 LoRA with the five fine-tuning steps below. X2HDR reports 14.2 stops of dynamic range on its own prompts and our rerun on 100 prompts measured 11.41, so plan around the lower figure[46][4].

Metrics to report together

Against a reference, report PU21-PSNR with the banding_glare coefficients and a peak of 256[78], HDR-VDP-3 in JOD[77], and \(\Delta E_{\mathrm{ITP}}\) for color[64]. Add mu-PSNR with \(\mu = 5000\) only to compare with NTIRE-style numbers[34]. Without a reference, report dynamic range in stops and the nits at the 99th luminance percentile. Together they show whether light moved into the highlights or the whole frame got brighter. Name the tone mapper behind every preview, since a score computed on a preview also scores that operator[3].

Delivery recipes

Each recipe assumes the pixels already hold PQ code values. The color tags are code points from ITU-T H.273, the standard that numbers primaries, transfer functions and matrices. They are 9 for BT.2020 primaries, 16 for PQ, 18 for HLG and 9 for the BT.2020 matrix[82]. Most routes start from a 16-bit PQ PNG, and a linear master goes to OpenEXR as 32-bit float.

# pq in [0, 1] from the ST 2084 inverse EOTF
# OpenCV channel order is BGR
cv2.imwrite("pq16.png", (pq * 65535 + 0.5).astype(np.uint16))
cv2.imwrite("out.exr", bgr.astype(np.float32))

Stills go to 10-bit PQ in AVIF or in HEIF, its HEVC-based counterpart.

avifenc -d 10 -y 444 --cicp 9/16/9 pq16.png out.avif
heif-enc -b 10 --colour_primaries 9 --transfer_characteristic 16 \
  --matrix_coefficients 9 pq16.png -o out.heic

Video goes to HDR10 in MP4, with the ST 2086 mastering display and MaxCLL, MaxFALL written by x265[82].

ffmpeg -i in_pq.mov -c:v libx265 -pix_fmt yuv420p10le \
  -color_primaries bt2020 -color_trc smpte2084 -colorspace bt2020nc \
  -x265-params "colorprim=bt2020:transfer=smpte2084:colormatrix=bt2020nc:\
master-display=G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,1):\
max-cll=1000,400" out.mp4

An SDR-compatible still goes to Ultra HDR JPEG through libultrahdr. Pass your own SDR base, the library's API-1 mode, to keep control of the tone mapping[57][55].

Five steps to fine-tune an LDM toward HDR

  1. Encode HDR training images into the range the frozen VAE already covers. X2HDR rescales linear RGB to a 4,000 nit peak, then PU21-encodes each channel to [0, 1], and LumiVid and DiffHDR use a log curve instead[46][49][48].
  2. Freeze the VAE and text encoder, and train a LoRA on the denoiser's attention query, key, value and output projections. X2HDR uses rank 32, about 3,000 steps on 4 GPUs, a learning rate of 1e-4 and a trigger token in the prompt[46].
  3. Keep the backbone's own loss, computed on the VAE latent \(z_0\) of the encoded target. For a rectified-flow backbone such as FLUX, Wan or LTX that is the flow-matching loss \(\lVert v_\theta(z_t, t) - (\epsilon - z_0) \rVert_2^2\), with \(v_\theta\) the predicted velocity, \(\epsilon\) Gaussian noise, \(t\) drawn from \([0, 1]\) and \(z_t = (1 - t)\,z_0 + t\,\epsilon\). LumiVid and Tedla et al. name it as their objective, and LEDiff, on Stable Diffusion, keeps the noise-prediction L2 loss[49][54][11].
  4. Crop the small HDR set hard. X2HDR turns 3,278 HDR images into 32,200 crops at 512 by 512[46]. For ITM, synthesize the SDR side with tone mappers, a gamut conversion and codec compression, as LumaFlux does[51], and degrade it. LumiVid reports that a network trained without degradations "learns a shortcut by simply stretching 8-bit steps into linear space" and posterizes[49].
  5. Decode with the frozen VAE, in FP32 once banding shows, which X2HDR sees in about 2 of 100 BF16 generations[46]. Then invert the encoding from step 1. Inverse PU21 returns nits on the 4,000 nit scale, and an inverse log curve returns relative linear light that you scale to a peak of your choosing. Convert the primaries to BT.2020 if the model works in BT.709, apply the PQ inverse EOTF, and continue with the delivery recipes.

DiffHDR and LumiVid follow the same steps on a video backbone, Tedla et al. fine-tune theirs to generate exposure brackets, and the video section lists all three configurations[48][49][54].

Four steps to guide a frozen sampler

  1. Choose a target \(h^{\star}\), a 32-bin PQ luminance histogram, from a preset, a reference image or the text-to-histogram regressor. The regressor was fit on about 24,000 Beyond8Bits frames, four per video[1].
  2. At each of the 28 sampling steps, decode the clean estimate \(\hat{x}_0\) and build a soft histogram of its PQ luminance over the same 32 bins. The LumaGuide section gives the equations[4].
  3. Take the Wasserstein-1 distance \(E\) from that histogram to \(h^{\star}\), backpropagate through the VAE decoder only, with the transformer under torch.no_grad(), and add \(s_0 \nabla_{z_t} E\) to the velocity, with \(z_t\) the current latent and \(s_0\) the guidance scale.
  4. Set \(s_0 = 2000\) on FLUX at 512 by 512, 1000 on SD3 or 50 on SDXL. On FLUX, sweep upward and stop by 3000, since uW1 stopped improving there for us and banding appears above it.

Three pitfalls

Tags on unencoded pixels. The H.273 tags label pixels as PQ and change none of them, so linear or PU21 values tagged as PQ play back at the wrong brightness. Outputs of DiffHDR, LumiVid and X2HDR are linear light and still need the scaling to nits and the PQ encode that end fine-tuning step 5. LumaFlux writes PQ directly and still needs the metadata.

Copied metadata. The master-display string in the HDR10 recipe is x265's own example for a P3-D65 display with a 1,000 nit peak and 0.0001 nit black, and "1000,400" is its example MaxCLL and MaxFALL[82]. Measure both light levels from your frames.

Clipped highlights. Guidance cannot move a pixel clamped at PQ 1.0[4], and ITM invents whatever the SDR input clipped. Mask the clipped regions and score them separately, since a whole-image number averages invented pixels with recovered ones.

References

  1. Shreshth Saini, Bowen Chen, Yilin Wang, Neil Birkbeck, Balu Adsumilli, Alan C. Bovik, Seeing Beyond 8bits: Subjective and Objective Quality Assessment of HDR-UGC Videos (HDR-Q model), CVPR 2026.
  2. Yi Wang, Yinan He, Yizhuo Li, Kunchang Li, Jiashuo Yu, Xin Ma, Xinhao Li, Guo Chen, Xinyuan Chen, Yaohui Wang, Conghui He, Ping Luo, Ziwei Liu, Yali Wang, Limin Wang, Yu Qiao, InternVid: A Large-scale Video-Text Dataset for Multimodal Understanding and Generation, arXiv 2307.06942, 2023.
  3. Param Hanji, Rafal K. Mantiuk, Gabriel Eilertsen, Saghi Hajisharif, Jonas Unger, Comparison of single image HDR reconstruction methods: the caveats of quality assessment, SIGGRAPH 2022 Conference Proceedings.
  4. Chen, Saini, Adsumilli, Bovik, LumaGuide: Distribution Shaping for Training-Free HDR Generation in Diffusion Models, arXiv 2026.
  5. Shreshth Saini, Bowen Chen, Yilin Wang, Neil Birkbeck, Balu Adsumilli, Alan C. Bovik, Seeing Beyond 8bits: Subjective and Objective Quality Assessment of HDR-UGC Videos, CVPR 2026.
  6. ITU-R, Recommendation BT.2035, A reference viewing environment for evaluation of HDTV program material or completed programmes, ITU 2013.
  7. SMPTE, ST 2084:2014, High Dynamic Range Electro-Optical Transfer Function of Mastering Reference Displays, SMPTE Standard 2014.
  8. ITU-R, Recommendation BT.2100-3, Image parameter values for high dynamic range television for use in production and international programme exchange, ITU 2025.
  9. Apple, Use HDR for dynamic image experiences in your app, WWDC24 session 10177, 2024.
  10. Soo Ye Kim, Jihyong Oh, Munchurl Kim, Deep SR-ITM: Joint Learning of Super-Resolution and Inverse Tone-Mapping for 4K UHD HDR Applications, ICCV 2019.
  11. Chao Wang, Zhihao Xia, Thomas Leimkuehler, Karol Myszkowski, Xuaner Zhang, LEDiff: Latent Exposure Diffusion for HDR Generation, CVPR 2025.
  12. Phongthawee, Chinchuthakun, Sinsunthithet, Jampani, Raj, Khungurn, Suwajanakorn, DiffusionLight: Light Probes for Free by Painting a Chrome Ball, CVPR 2024.
  13. Mark D. Fairchild, The HDR Photographic Survey, Color and Imaging Conference 2007.
  14. ITU-R, Recommendation BT.709-6: Parameter values for the HDTV standards for production and international programme exchange, 2015.
  15. ITU-R, Recommendation BT.1886-0: Reference electro-optical transfer function for flat panel displays used in HDTV studio production, 2011.
  16. ITU-R, Recommendation BT.2020-2: Parameter values for ultra-high definition television systems for production and international programme exchange, 2015.
  17. SMPTE, RP 431-2:2011, D-Cinema Quality: Reference Projector and Environment (the DCI P3 primaries and white point), SMPTE Recommended Practice 2011.
  18. ITU-R, Report BT.2246-9, The present state of ultra-high definition television, ITU 2025.
  19. ITU-R, Report BT.2390-12, High dynamic range television for production and international programme exchange, ITU 2025.
  20. IEC, IEC 61966-2-1:1999, Multimedia systems and equipment, Colour measurement and management, Part 2-1: Colour management, Default RGB colour space, sRGB, IEC 1999 (constants as transcribed on the W3C sRGB page and Wikipedia).
  21. ARIB, STD-B67 Version 1.0, Essential Parameter Values for the Extended Image Dynamic Range Television (EIDRTV) System for Programme Production, ARIB Standard 2015 (https://www.arib.or.jp/english/html/overview/doc/2-STD-B67v1_0.pdf); ITU-R, Recommendation BT.2100-3: Image parameter values for high dynamic range television for use in production and international programme exchange, 2025.
  22. CIE, 1931 2-degree standard observer colour matching functions (CIE 1931 2-deg XYZ CMFs, ciexyz31_1.csv at 1 nm), Colour and Vision Research Laboratory (CVRL) data tables, cvrl.org 1931.
  23. SMPTE, ST 2086:2018, Mastering Display Color Volume Metadata Supporting High Luminance and Wide Color Gamut Images, SMPTE 2018.
  24. E. Reinhard, M. Stark, P. Shirley, J. Ferwerda, Photographic Tone Reproduction for Digital Images, ACM Transactions on Graphics 21(3) (SIGGRAPH) 2002.
  25. Krzysztof Narkowicz, ACES Filmic Tone Mapping Curve, blog post 2016.
  26. Tsai-Shien Chen, Aliaksandr Siarohin, Willi Menapace, Ekaterina Deyneka, Hsiang-wei Chao, Byung Eun Jeon, Yuwei Fang, Hsin-Ying Lee, Jian Ren, Ming-Hsuan Yang, Sergey Tulyakov, Panda-70M: Captioning 70M Videos with Multiple Cross-Modality Teachers, CVPR 2024.
  27. Max Bain, Arsha Nagrani, Gul Varol, Andrew Zisserman, Frozen in Time: A Joint Video and Image Encoder for End-to-End Retrieval (WebVid-2M and WebVid-10M), ICCV 2021.
  28. Yilin Wang, Joong Gon Yim, Neil Birkbeck, Balu Adsumilli, YouTube SFV+HDR Quality Dataset, IEEE ICIP 2024.
  29. Zaixi Shang, Joshua P. Ebenezer, Alan C. Bovik, Yongjun Wu, Hai Wei, Sriram Sethuraman, Subjective Assessment of High Dynamic Range Videos Under Different Ambient Conditions (LIVE-HDR), IEEE ICIP 2022.
  30. Xiangyu Chen, Zhengwen Zhang, Jimmy S. Ren, Lynhoo Tian, Yu Qiao, Chao Dong, A New Journey from SDRTV to HDRTV, ICCV 2021.
  31. Shreshth Saini, Alan C. Bovik, Neil Birkbeck, Yilin Wang, Balu Adsumilli, CHUG: Crowdsourced User-Generated HDR Video Quality Dataset, ICIP 2025.
  32. Cheng Guo, Leidong Fan, Ziyu Xue, Xiuhua Jiang, Learning a Practical SDR-to-HDRTV Up-conversion using New Dataset and Degradation Models, CVPR 2023.
  33. Hiromi Nemoto, Pavel Korshunov, Philippe Hanhart, Touradj Ebrahimi, Visual attention in LDR and HDR images, International Workshop on Video Processing and Quality Metrics for Consumer Electronics (VPQM) 2015.
  34. Eduardo Perez-Pellitero, Sibi Catley-Chandar, Ales Leonardis, Radu Timofte, et al., NTIRE 2021 Challenge on High Dynamic Range Imaging: Dataset, Methods and Results, CVPR Workshops 2021.
  35. F. Banterle, K. Debattista, A. Artusi, S. Pattanaik, K. Myszkowski, P. Ledda, A. Chalmers, High Dynamic Range Imaging and Low Dynamic Range Expansion for Generating HDR Content, Computer Graphics Forum 28(8) 2009.
  36. A. G. Rempel, M. Trentacoste, H. Seetzen, H. D. Young, W. Heidrich, L. Whitehead, G. Ward, Ldr2Hdr: On-the-fly Reverse Tone Mapping of Legacy Video and Photographs, ACM Transactions on Graphics 26(3) (SIGGRAPH) 2007.
  37. B. Masia, S. Agustin, R. W. Fleming, O. Sorkine, D. Gutierrez, Evaluation of Reverse Tone Mapping Through Varying Exposure Conditions, ACM Transactions on Graphics 28(5) (SIGGRAPH Asia) 2009.
  38. Gabriel Eilertsen, Joel Kronander, Gyorgy Denes, Rafal K. Mantiuk, Jonas Unger, HDR image reconstruction from a single exposure using deep CNNs, ACM Transactions on Graphics (SIGGRAPH Asia) 2017.
  39. Endo, Kanamori, Mitani, Deep Reverse Tone Mapping, ACM TOG (SIGGRAPH Asia) 2017.
  40. P. E. Debevec, J. Malik, Recovering High Dynamic Range Radiance Maps from Photographs, SIGGRAPH 1997.
  41. D. Marnerides, T. Bashford-Rogers, J. Hatchett, K. Debattista, ExpandNet: A Deep Convolutional Neural Network for High Dynamic Range Expansion from Low Dynamic Range Content, Computer Graphics Forum 37(2) (Eurographics) 2018.
  42. Liu, Lai, Chen, Kao, Yang, Chuang, Huang, Single-Image HDR Reconstruction by Learning to Reverse the Camera Pipeline, CVPR 2020.
  43. Xiangyu Chen, Zheyuan Li, Zhengwen Zhang, Jimmy S. Ren, Yihao Liu, Jingwen He, Yu Qiao, Jiantao Zhou, Chao Dong, Towards Efficient SDRTV-to-HDRTV by Learning from Image Formation, IEEE Transactions on Multimedia 27, 2025.
  44. P. Raipurkar, R. Pal, S. Raman, HDR-cGAN: Single LDR to HDR Image Translation Using Conditional GAN, ICVGIP 2021.
  45. Wang, Serrano, Pan, Chen, Myszkowski, Seidel, Theobalt, Leimkühler, GlowGAN: Unsupervised Learning of HDR Images from LDR Images in the Wild, ICCV 2023.
  46. Wu, Su, Ma, Liao, Mantiuk, X2HDR: HDR Image Generation in a Perceptually Uniform Space, NeurIPS 2026.
  47. Bemana, Leimkühler, Myszkowski, Seidel, Ritschel, Bracket Diffusion: HDR Image Generation by Consistent LDR Denoising, Eurographics 2025.
  48. Yu et al., DiffHDR: Re-Exposing LDR Videos with Video Diffusion Models, ECCV 2026.
  49. Korem et al., HDR Video Generation via Latent Alignment with Logarithmic Encoding (LumiVid), arXiv 2026.
  50. Liu, Liu, Wang, Chen, Zeng, Liu, ExpoCM: Exposure-Aware One-Step Generative Single-Image HDR Reconstruction, CVPR 2026.
  51. Saini, Gedik, Birkbeck, Wang, Adsumilli, Bovik, LumaFlux: Lifting 8-Bit Worlds to HDR Reality with Physically-Guided Diffusion Transformers, arXiv 2026.
  52. D. Dalal, G. Vashishtha, P. Singh, S. Raman, Single Image LDR to HDR Conversion Using Conditional Diffusion, IEEE ICIP 2023.
  53. Fekri, Li, Chen, Altamirano, LatentHDR: Decoupling Exposure from Diffusion via Conditional Latent-to-Latent Mapping for Text/Image-to-Panoramic HDR, arXiv 2026.
  54. Tedla, Banterle, Canham, Raja, Lindell, Kutulakos, Li, Li, Iso, Generating HDR Video from SDR Video, SIGGRAPH Asia 2026.
  55. Google, Ultra HDR Image Format v1.1, Android developer documentation 2024.
  56. ISO/TC 42, ISO 21496-1:2025 Digital photography. Gain map metadata for image conversion. Part 1: Dynamic range conversion, ISO 2025.
  57. Google, libultrahdr: gain map image compression library, GitHub 2023 to 2026.
  58. Shreshth Saini, Hakan Gedik, Neil Birkbeck, Yilin Wang, Balu Adsumilli, Alan C. Bovik, LumaFlux public implementation, data recipe and evaluation protocol, GitHub 2026.
  59. Shreshth Saini, Bowen Chen, Neil Birkbeck, Yilin Wang, Balu Adsumilli, Alan C. Bovik, Beyond8Bits public release: README and metadata manifest (5,917 sources, 35,502 transcodes, 41,419 clips), GitHub 2026.
  60. Shreshth Saini, Hakan Gedik, Neil Birkbeck, Yilin Wang, Balu Adsumilli, Alan C. Bovik, LumaFlux project page, results on Luma-Eval and HDRTV1K, 2026.
  61. ITU-R, Report BT.2446, Methods for conversion of high dynamic range content to standard dynamic range content and vice-versa, ITU 2021.
  62. Gang Xu, Qibin Hou, Le Zhang, Ming-Ming Cheng, FMNet: Frequency-Aware Modulation Network for SDR-to-HDR Translation, ACM Multimedia 2022.
  63. Cheng Guo, Leidong Fan, Qian Zhang, Hanyuan Liu, Kanglin Liu, Xiuhua Jiang, Redistributing the Precision and Content in 3D-LUT-based Inverse Tone-mapping for HDR/WCG Display, CVMP 2023.
  64. ITU-R, Recommendation BT.2124-0: Objective metric for the assessment of the potential visibility of colour differences in television, 2019.
  65. Bowen Chen, Shreshth Saini, Balu Adsumilli, Alan C. Bovik, LumaGuide public implementation, GitHub 2026.
  66. Zicheng Zhang et al., Q-Eval-100K: Evaluating Visual Quality and Alignment Level for Text-to-Vision Content, CVPR 2025.
  67. Wei-Sheng Lai, Jia-Bin Huang, Oliver Wang, Eli Shechtman, Ersin Yumer, Ming-Hsuan Yang, Learning Blind Video Temporal Consistency, ECCV 2018.
  68. Yang Zhang, Zhangkai Ni, Wenhan Yang, Hanli Wang, Wavelet-Domain Masked Image Modeling for Color-Consistent HDR Video Reconstruction, arXiv 2026.
  69. Yuyao Ye, Ning Zhang, Yang Zhao, Hongbin Cao, Ronggang Wang, Deep Video Inverse Tone Mapping Based on Temporal Clues, CVPR 2024.
  70. Manish Narwaria, Matthieu Perreira Da Silva, Patrick Le Callet, HDR-VQM: An objective quality measure for high dynamic range video, Signal Processing: Image Communication 2015.
  71. Lightricks, LTX release notes, entries "HDR Video Generation (IC-LoRA)" of April 15, 2026 and "LTX-2.5" of August 11, 2026.
  72. Luma AI, Luma AI launches Ray3, September 18, 2025.
  73. Runway, API Changelog, entries of August 20, 2026 ("HDR output formats for Gen-4.5 and Aleph 2.0", "SDR to HDR in Runway API").
  74. Beeble, SwitchHDR: 16bit HDR from any video, July 3, 2026.
  75. ITU-R, Report BT.2408-8, Suggested guidance for operational practices in high dynamic range television production, ITU 2024.
  76. Rafal Mantiuk, Kil Joong Kim, Allan G. Rempel, Wolfgang Heidrich, HDR-VDP-2: A calibrated visual metric for visibility and quality predictions in all luminance conditions, ACM Transactions on Graphics (SIGGRAPH) 2011.
  77. Rafal K. Mantiuk, Dounia Hammou, Param Hanji, HDR-VDP-3: A multi-metric for predicting image differences, quality and contrast distortions in high dynamic range and regular content, arXiv 2023.
  78. Rafal K. Mantiuk, Maryam Azimi, PU21: A novel perceptually uniform encoding for adapting existing quality metrics for HDR, Picture Coding Symposium 2021.
  79. Lin Zhang, Hongyu Li, SR-SIM: A fast and high performance IQA index based on spectral residual, ICIP 2012.
  80. Shreshth Saini, Avinab Saha, Alan C. Bovik, HIDRO-VQA: High Dynamic Range Oracle for Video Quality Assessment, WACV Workshops 2024.
  81. Shreshth Saini, Bowen Chen, Yilin Wang, Neil Birkbeck, Balu Adsumilli, Alan C. Bovik, BrightRate: Quality Assessment for User-Generated HDR Videos, WACV 2026.
  82. MulticoreWare, x265 Command Line Options, x265 documentation.

Citation

@misc{saini2026sdrtohdr,
  author       = {Shreshth Saini},
  title        = {HDR Generation and SDR-to-HDR},
  year         = {2026},
  month        = mar,
  howpublished = {\url{https://shreshthsaini.github.io/blogs/sdr-to-hdr-generation.html}},
  note         = {Blog post}
}
@article{saini2026lumaflux,
  author  = {Shreshth Saini and Hakan Gedik and Neil Birkbeck and Yilin Wang and Balu Adsumilli and Alan C. Bovik},
  title   = {LumaFlux: Lifting 8-Bit Worlds to HDR Reality with Physically-Guided Diffusion Transformers},
  journal = {arXiv preprint arXiv:2604.02787},
  year    = {2026}
}
@article{chen2026lumaguide,
  author  = {Bowen Chen and Shreshth Saini and Balu Adsumilli and Alan C. Bovik},
  title   = {LumaGuide: Distribution Shaping for Training-Free HDR Generation in Diffusion Models},
  journal = {arXiv preprint arXiv:2607.26237},
  year    = {2026}
}
@inproceedings{Saini_2026_CVPR,
  author    = {Saini, Shreshth and Chen, Bowen and Wang, Yilin and Birkbeck, Neil and Adsumilli, Balu and Bovik, Alan C.},
  title     = {Seeing Beyond 8bits: Subjective and Objective Quality Assessment of HDR-UGC Videos},
  booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  month     = {June},
  year      = {2026},
  pages     = {15538-15549}
}
@inproceedings{Saini_2026_WACV,
  author    = {Saini, Shreshth and Chen, Bowen and Wang, Yilin and Birkbeck, Neil and Adsumilli, Balu and Bovik, Alan C.},
  title     = {BrightRate: Quality Assessment for User-Generated HDR Videos},
  booktitle = {Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision (WACV)},
  month     = {March},
  year      = {2026},
  pages     = {1522-1532}
}
@inproceedings{Saini_2025_ICIP_CHUG,
  author    = {Saini, Shreshth and Bovik, Alan C. and Birkbeck, Neil and Wang, Yilin and Adsumilli, Balu},
  title     = {CHUG: Crowdsourced User-Generated HDR Video Quality Dataset},
  booktitle = {2025 IEEE International Conference on Image Processing (ICIP)},
  year      = {2025},
  pages     = {2504-2509},
  doi       = {10.1109/ICIP55913.2025.11084488}
}