The ST 2084 Perceptual Quantizer: How an Absolute Luminance Curve Encodes 10,000 nits

Every transfer function before PQ encoded relative intensity: a stored value of 1.0 means “the display’s maximum”, whatever that maximum happens to be. The sRGB and Rec. 709 curves have no physical units attached, which is convenient for a fixed pipeline and useless for a signal that must survive transport to a display of unknown capability. PQ is defined the other way around: a stored value maps to a specific luminance in candelas per square metre, an absolute number, so a code value means the same light on every compliant display. That single reversal is the entire architectural change of HDR, and its consequences reach into storage precision, mastering, and every conversion in between.

Absolute luminance and why it is necessary

A relative signal cannot describe high dynamic range. If a pipeline encodes a scene into values in [0,1] where 1.0 is the brightest thing in the scene, then the stored image already contains a tone-map decision: the ratio between the brightest and dimmest representable value is fixed by the bit depth and the curve, not by the scene. An HDR signal wants to describe scene luminance directly, so that the display can apply its own tone map based on its own capability. That requires the values to carry units.

The unit is the nit, one candela per square metre. PQ maps stored code values to absolute nits, with a nominal range from a small fraction of a nit up to 10,000 nits. A reference display built to the standard reproduces that mapping exactly, so the mastering display and the delivery display agree on what each code value means, and the delivery display’s only job is to tone map values it cannot reach down into its own range. This is the opposite of the relative approach, where the display’s maximum defines the top of the range and every display is its own reference.

The cost of absoluteness is that a PQ signal is display-referred rather than scene-referred. The values have already been mapped to a display’s brightness range by the mastering process, so they do not carry scene radiance the way a linear render target does. A downstream operation that wants to relight or re-expose the content has to invert the mastering display’s tone map, which is not part of the standard and must be reconstructed.

The Barten model and the 10,000-nit ceiling

The curve’s shape is not chosen for photographic aesthetics; it is chosen so that a fixed quantization step is always at or below the threshold of visibility. The human eye’s contrast detection threshold as a function of adapting luminance is described by the Barten model, an equation that fits measured contrast sensitivity across a wide range of background luminance. PQ inverts that: the curve is spaced so that a one-code-value step is just below the visibility threshold at every luminance level, from the dimmest to the brightest.

This is a fundamentally different criterion from a power law. A power law of exponent 2.2 spaces codes so that the relative step is roughly constant in the mid-range but grows large at the extremes — precisely where the Barten threshold is also growing, so the two happen to agree in the middle and disagree at the ends. PQ’s curve is steeper near black and shallower near white than any power law, because the eye’s threshold changes that way.

The 10,000-nit upper bound is the value at which the Barten model was considered to hold with acceptable precision. Below roughly 0.005 nits the model’s validity breaks down, and the standard treats the lowest code values as effectively black; above 10,000 the model extrapolates. The practical consequence is that a 12-bit PQ signal spans a contrast ratio of roughly a million to one without visible banding, which is the number most often cited for the standard’s capability.

The EOTF itself, the function from code value to luminance, is a rational expression with an exponent of 1/2.4 (the value 78.84375 in the standard is the reciprocal written as a fraction). Its published form is

$$L = \left(\frac{\max(c^{1/m_2} - c_1, 0)}{c_2 - c_3 c^{1/m_2}}\right)^{1/m_1}$$

with the constants $m_1 = 2610/16384$, $m_2 = 2523/32$, $c_1 = 3424/4096$, $c_2 = 2413/128$, $c_3 = 2392/128$, and $c$ the normalized code value in [0,1]. The constants are all rational, which makes the expression exact in fixed-point arithmetic, a deliberate choice for hardware implementation. The $m_1$ and $m_2$ exponents are the fractional powers 0.1593 and 78.84375 respectively.

What the curve does to the bit budget

The most direct way to see PQ’s behaviour is to tabulate code values against luminance. At the bottom, the first few 12-bit codes above zero span only tiny fractions of a nit, because the eye is most sensitive to contrast there and the standard spends its codes where they matter. At the top, a single code step spans tens or hundreds of nits, because the eye cannot distinguish fine steps at 5000 nits. A 10-bit PQ signal allocates its 1024 codes the same way with a coarser step, and 10-bit PQ is generally considered adequate for ordinary HDR delivery, while 12-bit is specified for mastering to leave headroom for repeated processing without accumulating visible banding.

The contrast with sRGB is instructive. An 8-bit sRGB signal has a fixed relative step that is below threshold only in the middle of its range; at the top, a step is roughly 0.4% of the local value, which is visible on a bright display. PQ’s 10 bits are not merely two more bits than sRGB; they are two more bits placed by a perceptual model, which is worth far more than a uniform extension would be.

/* PQ EOTF: normalized code in [0,1] -> linear luminance in nits, scaled by peak. */
static float pq_eotf(float c, float peak_nits) {
    const float m1 = 2610.0f / 16384.0f;
    const float m2 = 2523.0f / 32.0f;
    const float c1 = 3424.0f / 4096.0f;
    const float c2 = 2413.0f / 128.0f;
    const float c3 = 2392.0f / 128.0f;
    float p = powf(c, 1.0f / m2);
    float num = p - c1;
    if (num < 0.0f) num = 0.0f;
    float L = powf(num / (c2 - c3 * p), 1.0f / m1);
    return L * peak_nits;   /* rescale to the mastering display's peak */
}

The peak_nits factor is the connection back to absoluteness: the standard curve produces a value normalized so that code 1.0 is 10,000 nits, and multiplying by the mastering display’s peak rescales it to the display that actually created the signal. The rescaling is the point where the absolute definition meets the reality that not every reference display reaches 10,000 nits.

The inverse and round-tripping

The inverse OETF maps nits back to code values, and it is the inverse of the rational expression, obtained by algebraically solving for $c$ given $L$. Round-tripping through the two curves is lossy by design at the low end, where the EOTF is extremely steep and the inverse compresses a wide range of dim luminances into a few codes. This is the same loss that any perceptual curve has, and it is why HDR pipelines keep their working data in linear float and apply the PQ encode only at delivery, exactly as sRGB pipelines apply their encode only at the boundary.

The round-trip loss matters for editing. Repeatedly decoding PQ to linear, adjusting, and re-encoding accumulates error near black because each re-encode re-quantizes the dim values into the same sparse codes. The standard’s answer is the higher bit depth at mastering: 12-bit PQ has four times the codes of 10-bit, which spreads the dim region out enough that a handful of round trips do not accumulate visible banding.

Relationship to the other HDR standard

PQ is one of two EOTFs standardized in BT.2100; the other is HLG, a relative, scene-referred curve designed for backward compatibility with SDR displays. The two solve different parts of the problem. PQ is absolute and display-referred, which is precise for a mastered signal but requires that the mastering display’s properties be known at encode time. HLG is relative and scene-referred, which survives unknown display capabilities and degrades gracefully to SDR, but does not guarantee that a given code value means the same light everywhere.

The choice between them is a broadcast-versus-mastering choice. PQ is the natural fit for content mastered to a known reference display and delivered as a finished grade; HLG is the natural fit for live or unknown-display delivery where the same signal must work on an SDR television and an HDR one. A pipeline that converts between them must convert through linear scene light and re-apply the destination curve, which is the same discipline described in conversion chains.

The display-referred nature of PQ also connects to tone mapping operators: a PQ signal arriving at a display that cannot reach the mastered peak must be tone mapped down, and the curve’s perceptual spacing is what makes that down-mapping clean rather than banded. The hue behaviour of that down-mapping is a separate concern covered in hue shifts in tone mapping.