From 7220dbde3cd3dde1e0dc59432cc8c4bf17d5f864 Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Mon, 30 Jan 2023 09:08:38 -0800
Subject: [PATCH 01/18] Initial refactoring

---
 hdr_html_canvas_element.md | 477 +++++++++++++------------------------
 1 file changed, 165 insertions(+), 312 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 31cc212..7a8e82a 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -1,32 +1,33 @@
-# Canvas High Dynamic Range
+# High Dynamic Range (HDR) HTML Canvas
 
-## Proposal summary / TLDR
+## Scope
 
-### Use cases
+We propose to extend the HTML Canvas API to support High Dynamic Range (HDR) imagery.
 
-There are four main classes of High Dynamic Range (HDR) use that inform this proposal. They are:
+## Primary requirements
 
-* To draw HDR content with the minimum performance overhead.
-* To draw HDR content in a way that will color match Standard Dynamic Range (SDR) content.
-  * Such that SDR images drawn in the canvas will appear exactly as they would if display in an `<img>` tag.
-* To display IUT-R BT.2100 Hybrid Log-Gamma (HLG) encoded HDR images and video in a canvas.
-  * Such that HLG images drawn in the canvas will appear exactly the same as they would if displayed via an `<img>` or `<video>` tag.
-* To display IUT-R BT.2100 Perceptual Quantiser (PQ) encoded HDR images and video in a canvas.
-  * Such that PQ images drawn in the canvas will appear exactly the same as they would if displayed via an `<img>` or `<video>` tag.
+* Minimum performance overhead
+* Draw Standard Dynamic Range (SDR) images such that these images appear as they would if display in an `<img>` tag
+* Draw IUT-R BT.2100 Hybrid Log-Gamma (HLG) encoded (HDR) images such that these images appear as they would if displayed via an
+  `<img>` or `<video>` tag
+* Draw IUT-R BT.2100 Perceptual Quantiser (PQ) encoded (HDR) images such that these images appear as they would if displayed via an
+  `<img>` or `<video>` tag
 
-### Proposed solution overview
+## Summary
 
-The solution that we propose is to:
+We propose to introduce:
 
-* Add attributes to the `ScreenAdvanced` interface to expose screen parameters relevant to high dynamic range and wide color gamut.
-* Introduce new color spaces and precisions that are useful for HDR.
-* Clearly define invertible and context-independent transformations between these spaces.
-* Introduce the ability use more than 8 bits per pixel for a canvas element.
-* Introduce the ability for an `HTMLCanvasElement`'s rendering context to configure HDR metadata.
+* three new HDR-specific color spaces: `srgb-linear`, `rec2100-hlg`, `rec2100-pq`
+* an HDR mode for the existing `srgb` color space
+* pixel bit depths greater than 8 bits
+* image parameters relevant to HDR rendering to the `HTMLCanvasElement`'s rendering context.
+* screen parameters relevant to HDR rendering using the `ScreenAdvanced` interface
+* fallback reference conversions between HDR color spaces
+* fallback reference conversion between SDR and HDR color spaces
 
 ## Proposal
 
-### Querying screen high dynamic range parameters
+### Querying screen HDR parameters
 
 Add a new attribute to `ScreenAdvanced` to indicate the HDR headroom currently available on the screen.
 
@@ -98,7 +99,7 @@ Add a new `CanvasColorMetadata` dictionary with HDR configuration options.
   }
 ```
 
-Add a mechanism for specifying this on `CanvasRenderingContext2D`, `OffscreenCanvasRenderingContext2D`, ``WebGLRenderingContextBase`, and `GPUCanvasContext`.
+Add a mechanism for specifying this on `CanvasRenderingContext2D`, `OffscreenCanvasRenderingContext2D`, `WebGLRenderingContextBase`, and `GPUCanvasContext`.
 
 For 2D canvas this would be:
 ```idl
@@ -121,101 +122,36 @@ For WebGPU this would be:
   }
 ```
 
-### Higher bit storage formats for 2D Canvas, WebGL and WebGPU
+### Pixel bit depths greater than 8 bits for Canvas, WebGL and WebGPU
 
-Canvas 2D's proposed [Canvas Floating Point Color Values](https://github.com/w3c/ColorWeb-CG/blob/main/canvas_float.md) allows for specifying higher bit depth canvas and ImageData.
+As implied by its names, HDR imagery requires more then 8 bits per component. Proposals to extend the HTML Canvas API and WebGL APIs are covered in other documents:
 
-WebGL's proposed [``drawingBufferStorage``](https://github.com/KhronosGroup/WebGL/pull/3222) function allows for specifying higher bit depth formats.
+* Canvas 2D's proposed [Canvas Floating Point Color Values](https://github.com/w3c/ColorWeb-CG/blob/main/canvas_float.md) allows for
+  specifying higher bit depth canvas and ImageData.
+* WebGL's proposed [``drawingBufferStorage``](https://github.com/KhronosGroup/WebGL/pull/3222) function allows for specifying higher
+  bit depth formats.
 
-WebGPU's ``GPUCanvasConfiguration`` can allow for specifying higher bit depth formats.
+[The WebGPU ``GPUCanvasConfiguration``](https://www.w3.org/TR/webgpu/#canvas-configuration) already allows 16-bit float values and
+can be further extended if needs be.
 
-### Display of floating point color values
+### Extend the existing `srgb` color space for HDR imagery
 
-Define a screen's native linear color space to be the color space with color primaries and white point set to the screen's `ScreenDetailed`'s `colorVolume` and the identity as its transfer function.
+Define a *screen's native linear color space* to be the color space with color primaries and white point set to the screen's
+`ScreenDetailed`'s `colorVolume` and the identity as its transfer function.
 
-A color is said to be within a screen's default range if, when that color is converted to the screen's native linear color space (using relative colorimetric intent), all of its color components are within the `[0, 1]` interval.
-When displaying content produced by a rendering context with `CanvasHighDynamicRangeMode` set to `'default'`, all colors that are within the screen's default range must be displayed without any clamping or roll-offs (neither in chrominance nor luminance).
+A color is said to be within a screen's *default* range if, when that color is converted to the screen's native linear color space
+(using relative colorimetric intent), all of its color components are within the `[0, 1]` interval. When displaying content produced
+by a rendering context with `CanvasHighDynamicRangeMode` set to `'default'`, all colors that are within the screen's default range
+must be displayed without any clamping or roll-offs (neither in chrominance nor luminance).
 
-A color is said to be within a screen's extended range if, when that color is converted to the screen's native linear color space (using relative colorimetric intent), all of its color components are within the `[0, highDynamicRangeHeadroom]` interval.
-When displaying content produced by a rendering context with `CanvasHighDynamicRangeMode` set to `'extended'`, all colors that are within the screen's extended range must be displayed without any clamping or roll-offs (neither in chrominance nor luminance).
+A color is said to be within a screen's *extended* range if, when that color is converted to the screen's native linear color space
+(using relative colorimetric intent), all of its color components are within the `[0, highDynamicRangeHeadroom]` interval. When
+displaying content produced by a rendering context with `CanvasHighDynamicRangeMode` set to `'extended'`, all colors that are within
+the screen's extended range must be displayed without any clamping or roll-offs (neither in chrominance nor luminance).
 
 Colors that do not fall under this guarantee should be clamped to the indicated range during display, but may be subject to screen-specific behavior.
 
-### Tone mapping
-
-As illustrated below, the proposal assumes that tone mapping, i.e. the rendering of an image with a given dynamic range onto a
-display with different dynamic range, occurs in different parts of the system depending on the color space of the Canvas element:
-
-* in the case where `rec2100-pq` are used, tone mapping is performed by the platform. This is akin to the
-  scenario where the `src` of an `img` element is a PQ image.
-
-* in the case where `rec2100-hlg` are used, tone mapping is performed by the display device. This is akin to the
-  scenario where the `src` of an `img` element is an HLG image.
-
-* in the case where any other color space is used (e.g, `srgb` or `srgb-linear`) tone mapping is performed by the web app, using display capabilities provided by the platform.
-
-![Tone mapping scenarios](./tone-mapping-scenarios.png)
-
-#### Suggested Tone mapping for HDR content on sRGB displays
-Not these are only used to tonemap HDR images at the point of rendering for display when the display is known to be an sRGB display.  They are not used for conversion between colour spaces which is defined in section XXXX.
-
-##### PQ signal
-
-##### HLG signal
-
-_Input:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
-
-_Output:_ Full-range non-linear floating-point `srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
-
-_Process:_
-  1. Pseudo-linearize the HLG signal exploiting its backwards compatibility with SDR consumer displays
-  2. Convert from ITU BT.2100 color space to sRGB color space
-  3. Convert back to non-linear using a reciprocal transform
-
-_Note 3_ This transform utilises the backwards compatibility of ITU-R BT.2100 HLG HDR with consumer electronic displays.  Prior to display, the gamut may need to be limited to the range 0-1.  The simplest method is to clip values but other gamut reduction techniques may provide better output images.
-
-```javascript
-
-function simpleTransform(value, systemGamma) { 
-  if (value < 1.0) { 
-    return -1.0 * Math.pow(-1.0 * value, systemGamma); 
-  } else { 
-    return Math.pow(value, systemGamma); 
-  } 
-}
-
-function simpleInverseTransform(value, systemGamma) { 
-  if (value < 1.0) { 
-    return -1.0 * Math.pow(-1.0 * value, 1.0 / systemGamma); 
-  } else { 
-    return Math.pow(value, 1.0 / systemGamma); 
-  } 
-} 
-
-function tonemapREC2100HLGtoSRGBdisplay(r, g, b) {
-  const systemGamma = 2.2;
-  const r1 = simpleTransform(r, systemGamma);
-  const g1 = simpleTransform(g, systemGamma);
-  const b1 = simpleTransform(b, systemGamma);
-  const [r2, g2, b2] = matrixXYZtoSRGB(matrixBT2020toXYZ(r1, g1, b1));
-  const r3 = simpleInverseTransform(r2, systemGamma);      
-  const g3 = simpleInverseTransform(g2, systemGamma); 
-  const b3 = simpleInverseTransform(b2, systemGamma); 
-  const [r4, g4, b4] = limitTosRGBGamut(r3, g3, b3);
-  return [r4, g4, b4];
-}
-```
-
-##### extended sRGB signal
-
-Extended sRGB contains information that is outside of the capabilities of an sRGB monitor.  For this reason, the extended sRGB must first be converted for display.  
-The extended sRGB signal can be converted for display on an sRGB monitor by first converting to HLG or PQ and then applying the relevant tonemapping to sRGB for displays.  For example:
-```javascript
-const [r_display, g_display, b_display] = tonemapREC2100HLGtoSRGBdisplay(
-       convertExtendedSRGBtoREC2100HLG(r_extended_srgb, g_extended_srgb, b_extended_srgb));
-```
-
-### Color spaces
+### New HDR-specific color spaces
 
 #### General
 
@@ -229,28 +165,23 @@ Update `PredefinedColorSpace` to include the following color spaces.
   }
 ```
 
-#### srgb and display-p3
+As illustrated below, the proposal assumes that tone mapping, i.e. the rendering of an image with a given dynamic range onto a
+display with different dynamic range, occurs in different parts of the system depending on the color space of the Canvas element:
 
-There already exist defined color spaces `srgb` and `display-p3`.
+* in the case where `rec2100-pq` are used, tone mapping is performed by the platform. This is akin to the scenario where the `src`
+  of an `img` element is a PQ image.
 
-Note that the transfer function for these spaces [is already defined](https://www.w3.org/TR/css-color-4/#predefined) on all real numbers (not just the unit interval), as:
+* in the case where `rec2100-hlg` are used, tone mapping is performed by the display device. This is akin to the scenario where the
+  `src` of an `img` element is an HLG image.
 
-```javascript
-  function electroOpticalTransferFunction(c) {
-    let sign = c < 0? -1 : 1;
-    let abs = Math.abs(c);
-    if (abs <= 0.04045) {
-      return = c / 12.92;
-    }
-    else {
-      return = sign * (Math.pow((abs + 0.055) / 1.055, 2.4));
-    }
-  }
-```
+* in the case where any other color space is used (e.g, `srgb` or `srgb-linear`) tone mapping is performed by the web app, using
+  display capabilities provided by the platform.
+
+![Tone mapping scenarios](./tone-mapping-scenarios.png)
 
 #### srgb-linear
 
-This color space uses the same primaries as `srgb`, but with the identity function as the transfer function.
+This color space uses the same primaries and white point as `srgb`, but with the identity function as the transfer function.
 
 ```javascript
   function electroOpticalTransferFunction(c) {
@@ -266,167 +197,85 @@ The component signals are mapped to red, green and blue tristimulus values accor
 
 The component signals are mapped to red, green and blue tristimulus values according to the Perceptual Quantizer (PQ) system system specified in Rec. ITU-R BT.2100.
 
-### Conversion between color spaces
-
-#### General
-
-There are several places in the HTML specification where a color space conversion is required (e.g, when [drawing images to a
-canvas](https://html.spec.whatwg.org/multipage/canvas.html#colour-spaces-and-colour-correction), [retrieving image data from a
-canvas](https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-getimagedata), among others being added). There exists a
-standard conversion that is applied to all data in these situations, namely, a conversion using relative colorimetric intent.
-
-This operation is defined for [CSS Predefined Color Spaces](https://www.w3.org/TR/css-color-4/#predefined) in the HTML specification
-[here](https://www.w3.org/TR/css-color-4/#predefined-to-lab).
-
-In this section we define this conversion for the new predefined color spaces.
-
-These conversions are expressed using a connection color space with the system colorimetry specified in Rec. ITU-R BT.2100:
-
-* Red primary: `(0.708, 0.292)`
-* Green chromaticity: `(0.170, 0.797)`
-* Blue chromaticity: `(0.131, 0.046)`
-* White chromaticity (D65): `(0.3127, 0.3290)`
-
-_Note:_ The system colorimetry specified in Rec. ITU-R BT.2100 is identical to that specified in Rec. ITU-R BT.2020.
-
-The conversion from color space A to color space B is performed according to the following steps:
-
-* apply the inverse transfer function of color space A
-* convert to the connection space by multiplying by the connection matrix of color space A
-* convert to color space B by multiplying by by the inverse of the connection matrix of color space B
-* apply any linear light scaling to correctly map the level of perceived diffuse white level in to color space B
-* apply the transfer function of color space B
-
-The domain and range of this conversion consist of all real values and the component signals in the connection color space are real numbers.
-
-#### `srgb-linear`
-
-* Transfer function: identity
-
-* Connection matrix: matrix to convert the [sRGB primaries](https://www.w3.org/TR/css-color-4/#valdef-color-srgb) to the primary colours specified in Rec. ITU-R BT.2100
-
-* Linear light scaling: 1.0
-
-#### `srgb`
+### Color space conversions
 
-* Transfer function: See [srgb-linear](#srgb-linear)
+#### Background
 
-* Connection matrix: matrix to convert the [sRGB primaries](https://www.w3.org/TR/css-color-4/#valdef-color-srgb) to the primary colours specified in Rec. ITU-R BT.2100
+In general, application should avoid conversions between color spaces and maintain imagery in its original color space: conversions
+between color spaces are not necessarily reversible and do not necessarily result in the same image appearance. In particular,
+conversion of an HDR image to an SDR will result in a signification loss of information and an SDR image that is different from the
+SDR image that would have been mastered from the same source material. From that perspective, converting from HDR to SDR imagery is
+no different than converting RGBA images to 16-color pallette images.
 
-* Linear light scaling: 1.0
-
-_Note:_ The domain of this transformation function is all real values. Its domain is not restricted to the unit interval [0, 1].
-
-Also see note in the Issues section at the bottom about whether this space should be distinct from the existing `'srgb'` space.
-
-#### `rec2100-hlg`
-
-
-* Transfer function: The HLG Reference inverse OETF specified at Rec. ITU-R BT.2100, scaled
-
-```javascript
-  function connectionTransferFunction(x) {
-    const a = 0.17883277;
-    const b = 1 - 4*a;
-    const c = 0.5 - a * Math.log(4 * a);
-    const k = (Math.exp((0.75 - c) / a) + b) / 12;
-    if (x < 0) {
-      return 0;
-    } else if (x <= 0.5) {
-      return x * x / (3 * k);
-    } else if (x <= 1) {
-      return (Math.exp((v - c) / a) + b) / (12 *  k);
-    } else {
-      return 1 / scale;
-    }
-```
-
-_Note:_ the factor `k` is selected such that a signal of `0.75` results in a linear color value of 1 in the connection color space.
+Nevertheless, the HTML specification allows color space conversion in several scenarios, e.g., when [drawing images to a
+canvas](https://html.spec.whatwg.org/multipage/canvas.html#colour-spaces-and-colour-correction), [retrieving image data from a
+canvas](https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-getimagedata), among others being added). The conversions
+between predefined SDR color spaces are defined at <https://www.w3.org/TR/css-color-4/>, and this proposal similarly defines
+conversions for HDR color spaces.
 
-* Connection matrix: Identity
+These conversions fall into two broad categories:
 
-#### `rec2100-pq`
+* conversion between HDR color spaces
+* conversion between an HDR and an SDR color space (tone mapping)
 
-* Transfer function: The inverse of the Reference PQ EOTF specified at Rec. ITU-R BT.2100, scaled
+#### Between HDR color spaces
 
-```javascript
-  function connectionTransferFunction(x) {
-    const c1 =  107 / 128;
-    const c2 = 2413 / 128;
-    const c3 = 2392 / 128;
-    const m1 = 1305 / 8192;
-    const m2 = 2523 / 32;
-    const k = 203;
-    if (x < 0) {
-      return 0;
-    } else if (x <= 1) {
-      const p = Math.pow(x, 1 / m2);
-      return (10000 / k) * Math.pow((p - c1) / (c2 - c3 * p), 1 / m1);
-    } else {
-      return (10000 / k);
-    }
-```
+##### General
 
-_Note:_ The factor `k` is selected such that a display luminance of 203 cd/m<sup>2</sup> results in a linear color value of 1 in the connection color space.
+Conversions to and from extended `srgb` are not included since extended `srgb` is trivially converted to and from `srgb-linear`.
 
+Conversions between `rec2100-hlg` and `rec2100-pq` are implicitly specified through conversions to and from `srgb-linear`.
 
-#### Conversions via Color Connection Space
+The domain and range of the conversions consist of all real values.
 
-##### Conversion from extended-sRGB to HLG
+##### `rec2100-hlg` to `srgb-linear`
 
-_Input:_ Full-range non-linear floating-point `extended-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
+_Input:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
 
-_Output:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
+_Output:_ Full-range non-linear floating-point `srgb-linear` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
 
 _Process:_
- 1. Linearize using the SRGB EOTF
- 2. Convert from `extended-srgb` color space to `rec2100-hlg` color space
- 3. Scale pixel values - See Note 1
- 4. Apply HLG Inverse EOTF to convert to HLG from Pseudo-Display Light with Lw = 302 cd/m2 - See Note 1
-  * apply HLG Inverse OOTF
-  * apply HLG OETF - See Note 2
 
-_Note 1:_ As `rec2100-hlg` is a relative format, the brightness of the virtual monitor used for mathematical transforms can be chosen to be any level. In this transform it is chosen to be 302 cd/m2 so that the brightness of diffuse white matches the diffuse white of sRGB (80 cd/m2). Using the extended range gamma formula in footnote 2 of BT.2100, this also sets the HLG Inverse OOTF to be unity. The value 0.265 is calculated by taking the inverse OETF of 0.75, the `rec2100-hlg` diffuse white level.
-
-_Note 2:_ See section 5.3 in ITU-R BT.2408-4 relating to negative transfer functions in format conversions.
+1. Apply HLG EOTF to convert the non-linear `rec2100-hlg` Signal to linear Pseudo-Display Light with Lw = 302 cd/m2 - See Note 1
+    * apply inverse HLG OETF
+    * apply HLG OOTF to derive linear display light
+2. Scale pixel values
+3. Convert from ITU BT.2100-1 color to SRGB color
 
 ```javascript
-function convertExtendedSRGBtoREC2100HLG(r, g, b) {
+function convertREC2100HLGtoLinearSRGB(r, g, b) {
   const systemGamma = 1.0;
-  const linearLightScaler = 0.26496256042100724;
-
-  const r1 = srgb_eotf(r);
-  const g1 = srgb_eotf(g);
-  const b1 = srgb_eotf(b);
+  const linearLightScaler = 1.0 / 0.26496256042100724;
 
-  const [r2, g2, b2] = matrixXYZtoBT2020(matrixSRGBtoXYZ(r1,g1,b1));
+  const [r1, g1, b1] = hlg_inverse_oetf(r, g, b);
+  const [r2, g2, b2] = hlg_ootf(r1, g1, b1, systemGamma);
 
   const r3 = linearLightScaler * r2;
   const g3 = linearLightScaler * g2;
   const b3 = linearLightScaler * b2;
 
-  const [r4, g4, b4] = hlg_inverse_ootf(r3, g3, b3, systemGamma);
-  const [r5, g5, b5] = hlg_oetf(r4, g4, b4);
+  const [r4, g4, b4] = matrixXYZtoSRGB(matrixBT2020toXYZ(r3, g3, b3));
 
-  return [r5, g5, b5]
+  return [r4, g4, b4];
 }
 ```
 
-##### Conversion from extended-linear-sRGB to HLG
+##### `srgb-linear` to `rec2100-hlg`
 
-_Input:_ Full-range non-linear floating-point `extended-linear-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
+_Input:_ Full-range non-linear floating-point `srgb-linear` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
 
 _Output:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
 
 _Process:_
-1. Convert from `extended-linear-srgb` color space to `rec2100-hlg` color space
+
+1. Convert from `extended-srgb-linear` color to `rec2100-hlg` color
 2. Scale pixel values - See Note 1
 3. Apply HLG Inverse EOTF to convert to HLG from Pseudo-Display Light with Lw = 302 cd/m2 - See Note 1
- * apply HLG Inverse OOTF
- * apply HLG OETF - See Note 2
+    * apply HLG Inverse OOTF
+    * apply HLG OETF - See Note 2
 
 ```javascript
-function convertExtendedLinearSRGBtoREC2100HLG(r, g, b) {
+function convertLinearSRGBtoREC2100HLG(r, g, b) {
   const systemGamma = 1.0;
   const linearLightScaler = 0.26496256042100724;
 
@@ -435,114 +284,118 @@ function convertExtendedLinearSRGBtoREC2100HLG(r, g, b) {
   const r3 = linearLightScaler * r2;
   const g3 = linearLightScaler * g2;
   const b3 = linearLightScaler * b2;
-  
+
   const [r4, g4, b4] = hlg_inverse_ootf(r3, g3, b3, systemGamma);
   const [r5, g5, b5] = hlg_oetf(r4, g4, b4);
-  
+
   return [r5, g5, b5];
 }
 ```
 
-##### Conversion from extended-sRGB to PQ
-
-_Input:_ Full-range non-linear floating-point `extended-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
-
-_Output:_ Full-range non-linear floating-point `rec2100-pq` pixel with black at 0.0 and diffuse white at ???. Values may exist outside the range 0.0 to 1.0.
+_Note 1:_ As `rec2100-hlg` is a relative format, the brightness of the virtual monitor used for mathematical transforms can be chosen to be any level. In this transform it is chosen to be 302 cd/m2 so that the brightness of diffuse white matches the diffuse white of sRGB (80 cd/m2). Using the extended range gamma formula in footnote 2 of BT.2100, this also sets the HLG Inverse OOTF to be unity. The value 0.265 is calculated by taking the inverse OETF of 0.75, the `rec2100-hlg` diffuse white level.
 
-_Process:_
+_Note 2:_ See section 5.3 in ITU-R BT.2408-4 relating to negative transfer functions in format conversions.
 
-##### Conversion from extended-sRGB to PQ
+##### `srgb-linear` to `rec2100-pq`
 
-_Input:_ Full-range non-linear floating-point `extended-linear-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
+_Input:_ Full-range non-linear floating-point `srgb-linear` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
 
 _Output:_ Full-range non-linear floating-point `rec2100-pq` pixel with black at 0.0 and diffuse white at ???. Values may exist outside the range 0.0 to 1.0.
 
 _Process:_
 
-##### Conversion from HLG to extended-sRGB
+```javascript
+  function connectionTransferFunction(x) {
+    const c1 =  107 / 128;
+    const c2 = 2413 / 128;
+    const c3 = 2392 / 128;
+    const m1 = 1305 / 8192;
+    const m2 = 2523 / 32;
+    const k = 203;
+    if (x < 0) {
+      return 0;
+    } else if (x <= 1) {
+      const p = Math.pow(x, 1 / m2);
+      return (10000 / k) * Math.pow((p - c1) / (c2 - c3 * p), 1 / m1);
+    } else {
+      return (10000 / k);
+    }
+```
+
+_Note:_ The factor `k` is selected such that a display luminance of 203 cd/m<sup>2</sup> results in a linear color value of 1 in `srgb-linear`.
 
-_Input:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
+##### `srgb-linear` to `rec2100-pq`
+
+_Input:_ Full-range non-linear floating-point `extended-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
 
-_Output:_ Full-range non-linear floating-point `extended-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
+_Output:_ Full-range non-linear floating-point `rec2100-pq` pixel with black at 0.0 and diffuse white at ???. Values may exist outside the range 0.0 to 1.0.
 
 _Process:_
-1. Apply HLG EOTF to convert the non-linear `rec2100-hlg` Signal to linear Pseudo-Display Light with Lw = 302 cd/m2 - See Note 1
- * apply inverse HLG OETF
- * apply HLG OOTF to derive linear display light
-2. Scale pixel values
-3. Convert from ITU BT.2100-1 color space to SRGB color space
-4. Convert to non-linear SRGB using the SRGB Inverse EOTF
 
+#### Between SDR and HDR color spaces
 
-```javascript
-function convertREC2100HLGtoExtendedSRGB(r, g, b) {
-  const systemGamma = 1.0;
-  const linearLightScaler = 1.0 / 0.26496256042100724;
+##### General
 
-  const [r1, g1, b1] = hlg_inverse_oetf(r, g, b);
-  const [r2, g2, b2] = hlg_ootf(r1, g1, b1, systemGamma);
+Conversions to and from `srgb` are provided for `rec2100-pq` and `rec2100-hlg` color spaces. Extended `srgb` images can be converted
+for display on an sRGB monitor by first converting to `rec2100-pq` and `rec2100-hlg` first and then applying the relevant conversion
+to `srgb`.
 
-  const r3 = linearLightScaler * r2;
-  const g3 = linearLightScaler * g2;
-  const b3 = linearLightScaler * b2;
+##### `rec2100-pq` to `srgb`
 
-  const [r4, g4, b4] = matrixXYZtoSRGB(matrixBT2020toXYZ(r3, g3, b3));
-  const r5 = srgb_inverse_eotf(r4);
-  const g5 = srgb_inverse_eotf(g4);
-  const b5 = srgb_inverse_eotf(b4);
+See Annex B at SMPTE ST 2094-10.
 
-  return [r5, g5, b5];
-}
-```
+##### `rec2100-hlg` to `srgb`
 
-##### Conversion from HLG to extended-linear-sRGB
+_Input:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
 
-  _Input:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
+_Output:_ Full-range non-linear floating-point `srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
 
-  _Output:_ Full-range non-linear floating-point `extended-linear-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
+_Process:_
+  1. Pseudo-linearize the HLG signal exploiting its backwards compatibility with SDR consumer displays
+  2. Convert from ITU BT.2100 color space to sRGB color space
+  3. Convert back to non-linear using a reciprocal transform
 
-  _Process:_
-  1. Apply HLG EOTF to convert the non-linear `rec2100-hlg` Signal to linear Pseudo-Display Light with Lw = 302 cd/m2 - See Note 1
-   * apply inverse HLG OETF
-   * apply HLG OOTF to derive linear display light
-  2. Scale pixel values
-  3. Convert from ITU BT.2100-1 color space to SRGB color space
+_Note 3_ This transform utilises the backwards compatibility of ITU-R BT.2100 HLG HDR with consumer electronic displays.  Prior to display, the gamut may need to be limited to the range 0-1.  The simplest method is to clip values but other gamut reduction techniques may provide better output images.
 
 ```javascript
-function convertREC2100HLGtoExtendedLinearSRGB(r, g, b) {
-  const systemGamma = 1.0;
-  const linearLightScaler = 1.0 / 0.26496256042100724;
-
-  const [r1, g1, b1] = hlg_inverse_oetf(r, g, b);
-  const [r2, g2, b2] = hlg_ootf(r1, g1, b1, systemGamma);
 
-  const r3 = linearLightScaler * r2;
-  const g3 = linearLightScaler * g2;
-  const b3 = linearLightScaler * b2;
+function simpleTransform(value, systemGamma) { 
+  if (value < 1.0) { 
+    return -1.0 * Math.pow(-1.0 * value, systemGamma); 
+  } else { 
+    return Math.pow(value, systemGamma); 
+  } 
+}
 
-  const [r4, g4, b4] = matrixXYZtoSRGB(matrixBT2020toXYZ(r3, g3, b3));
+function simpleInverseTransform(value, systemGamma) { 
+  if (value < 1.0) { 
+    return -1.0 * Math.pow(-1.0 * value, 1.0 / systemGamma); 
+  } else { 
+    return Math.pow(value, 1.0 / systemGamma); 
+  } 
+} 
 
+function tonemapREC2100HLGtoSRGBdisplay(r, g, b) {
+  const systemGamma = 2.2;
+  const r1 = simpleTransform(r, systemGamma);
+  const g1 = simpleTransform(g, systemGamma);
+  const b1 = simpleTransform(b, systemGamma);
+  const [r2, g2, b2] = matrixXYZtoSRGB(matrixBT2020toXYZ(r1, g1, b1));
+  const r3 = simpleInverseTransform(r2, systemGamma);      
+  const g3 = simpleInverseTransform(g2, systemGamma); 
+  const b3 = simpleInverseTransform(b2, systemGamma); 
+  const [r4, g4, b4] = limitTosRGBGamut(r3, g3, b3);
   return [r4, g4, b4];
 }
 ```
 
+##### `srgb` to `rec2100-hlg`
 
-##### Conversion from PQ to extended-sRGB
-
-  _Input:_ Full-range non-linear floating-point `rec2100-pq` pixel with black at 0.0 and diffuse white at ???. Values may exist outside the range 0.0 to 1.0.
-
-  _Output:_ Full-range non-linear floating-point `extended-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
-
-  _Process:_
-
-##### Conversion from PQ to extended-linear-sRGB
-
-  _Input:_ Full-range non-linear floating-point `rec2100-pq` pixel with black at 0.0 and diffuse white at ???. Values may exist outside the range 0.0 to 1.0.
-
-  _Output:_ Full-range non-linear floating-point `extended-linear-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
+See [TTML 2, Annex Q.2, steps 1-8](https://www.w3.org/TR/ttml2/#hlg-hdr) with `tts:luminanceGain = 203/80`.
 
-  _Process:_
+##### `srgb` to `rec2100-pq`
 
+See [TTML 2, Annex Q.1, steps 1-8](https://www.w3.org/TR/ttml2/#hdr-compositing).
 
 ### Compositing the HDR `HTMLCanvasElement`
 

From 3a07c6ccee03cb15d3260d9556794cffbc209cbf Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Mon, 30 Jan 2023 09:34:13 -0800
Subject: [PATCH 02/18] Add rec2100-pq HDR conversions

---
 hdr_html_canvas_element.md | 65 +++++++++++++++++++++++++-------------
 1 file changed, 43 insertions(+), 22 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 7a8e82a..299b8f3 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -298,40 +298,61 @@ _Note 2:_ See section 5.3 in ITU-R BT.2408-4 relating to negative transfer funct
 
 ##### `srgb-linear` to `rec2100-pq`
 
-_Input:_ Full-range non-linear floating-point `srgb-linear` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
+_Input:_ Full-range non-linear floating-point `srgb-linear` pixel. Values may exist outside the range 0.0 to 1.0.
 
-_Output:_ Full-range non-linear floating-point `rec2100-pq` pixel with black at 0.0 and diffuse white at ???. Values may exist outside the range 0.0 to 1.0.
+_Output:_ Full-range non-linear floating-point `rec2100-pq` pixel in the range 0.0 to 1.0.
 
 _Process:_
 
+1. Convert from sRGB color to Rec. ITU-R BT.2020 color
+2. Apply PQ Inverse EOTF, mapping such that a luminance of 203 cd/m<sup>2</sup> results in a value 1.0 in `srgb-linear`.
+
 ```javascript
-  function connectionTransferFunction(x) {
-    const c1 =  107 / 128;
-    const c2 = 2413 / 128;
-    const c3 = 2392 / 128;
-    const m1 = 1305 / 8192;
-    const m2 = 2523 / 32;
-    const k = 203;
-    if (x < 0) {
-      return 0;
-    } else if (x <= 1) {
-      const p = Math.pow(x, 1 / m2);
-      return (10000 / k) * Math.pow((p - c1) / (c2 - c3 * p), 1 / m1);
-    } else {
-      return (10000 / k);
-    }
-```
+function convertLinearSRGBtoREC2100PQ(r, g, b) {
 
-_Note:_ The factor `k` is selected such that a display luminance of 203 cd/m<sup>2</sup> results in a linear color value of 1 in `srgb-linear`.
+  const p2 = matrixXYZtoBT2020(matrixSRGBtoXYZ(r, g, b));
 
-##### `srgb-linear` to `rec2100-pq`
+  const k = 203;
+
+  let p3 = []
+  for (let i = 0; i < 3; i++) {
+
+    if (p2[i] < 0)
+      p3[i] = 0;
+    else if (p2[i] <= 10000/k) {
+      p3[i] = pqInverseEOTF(k * p2[i]);
+    else
+      p3[i] = 1.0;
+  }
+
+  return p3;
+}
+```
+
+##### `rec2100-pq` to `srgb-linear`
 
-_Input:_ Full-range non-linear floating-point `extended-srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
+_Input:_ Full-range non-linear floating-point `rec2100-pq` pixel in the range 0.0 to 1.0.
 
-_Output:_ Full-range non-linear floating-point `rec2100-pq` pixel with black at 0.0 and diffuse white at ???. Values may exist outside the range 0.0 to 1.0.
+_Output:_ Full-range non-linear floating-point `srgb-linear` pixel. Values may exist outside the range 0.0 to 1.0.
 
 _Process:_
 
+1. Apply PQ Inverse EOTF, mapping such that a luminance of 203 cd/m<sup>2</sup> results in a value 1.0 in `srgb-linear`.
+2. Convert from Rec. ITU-R BT.2020 color to sRGB color
+
+```javascript
+function convertREC2100PQToLinearSRGB(r, g, b) {
+
+  const k = 203;
+
+  const r3 = pqEOTF(r) / k;
+  const g3 = pqEOTF(g) / k;
+  const b3 = pqEOTF(b) / k;
+
+  return matrixXYZtoSRGB(matrixBT2020toXYZ(r3, g3, b3));
+}
+```
+
 #### Between SDR and HDR color spaces
 
 ##### General

From aebfc6f6c3b09e66934d83756a3ec17c5e1c119c Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Mon, 30 Jan 2023 09:44:00 -0800
Subject: [PATCH 03/18] Color space conversion illustration

---
 color-space-conversions.png | Bin 0 -> 5542 bytes
 hdr_html_canvas_element.md  |   4 ++++
 2 files changed, 4 insertions(+)
 create mode 100644 color-space-conversions.png

diff --git a/color-space-conversions.png b/color-space-conversions.png
new file mode 100644
index 0000000000000000000000000000000000000000..bea0911a41e409dd75a1a54a2a9739a029e10b18
GIT binary patch
literal 5542
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

literal 0
HcmV?d00001

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 299b8f3..700580a 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -213,6 +213,10 @@ canvas](https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-getima
 between predefined SDR color spaces are defined at <https://www.w3.org/TR/css-color-4/>, and this proposal similarly defines
 conversions for HDR color spaces.
 
+The following illustrates the conversions that are explicitly specified:
+
+![Color space conversions](./color-space-conversions.png)
+
 These conversions fall into two broad categories:
 
 * conversion between HDR color spaces

From e5bb8a46c32865fc61776b7ed85a1a17f135001a Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Thu, 23 Feb 2023 21:09:14 -0800
Subject: [PATCH 04/18] In progress

---
 hdr_html_canvas_element.md | 265 +++++++++----------------------------
 1 file changed, 61 insertions(+), 204 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 700580a..fb4388a 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -7,7 +7,8 @@ We propose to extend the HTML Canvas API to support High Dynamic Range (HDR) ima
 ## Primary requirements
 
 * Minimum performance overhead
-* Draw Standard Dynamic Range (SDR) images such that these images appear as they would if display in an `<img>` tag
+* Draw SDR content in an HDR canvas with the result being identical  the same SDR content had been drawn in an SDR canvas
+* Draw Standard Dynamic Range (SDR) images such that these images appear as they would if displayed in an `<img>` tag
 * Draw IUT-R BT.2100 Hybrid Log-Gamma (HLG) encoded (HDR) images such that these images appear as they would if displayed via an
   `<img>` or `<video>` tag
 * Draw IUT-R BT.2100 Perceptual Quantiser (PQ) encoded (HDR) images such that these images appear as they would if displayed via an
@@ -17,10 +18,9 @@ We propose to extend the HTML Canvas API to support High Dynamic Range (HDR) ima
 
 We propose to introduce:
 
-* three new HDR-specific color spaces: `srgb-linear`, `rec2100-hlg`, `rec2100-pq`
-* an HDR mode for the existing `srgb` color space
-* pixel bit depths greater than 8 bits
-* image parameters relevant to HDR rendering to the `HTMLCanvasElement`'s rendering context.
+* two new color spaces: `rec2100-hlg`, `rec2100-pq`
+* define new HDR semantics for existing `PredefinedColorSpace` color spaces
+* color metadata relevant to HDR rendering to the `HTMLCanvasElement`'s rendering context.
 * screen parameters relevant to HDR rendering using the `ScreenAdvanced` interface
 * fallback reference conversions between HDR color spaces
 * fallback reference conversion between SDR and HDR color spaces
@@ -124,7 +124,8 @@ For WebGPU this would be:
 
 ### Pixel bit depths greater than 8 bits for Canvas, WebGL and WebGPU
 
-As implied by its names, HDR imagery requires more then 8 bits per component. Proposals to extend the HTML Canvas API and WebGL APIs are covered in other documents:
+As implied by its names, HDR imagery benefits from more then 8 bits per component. Proposals to extend the HTML Canvas API and WebGL
+APIs are covered in other documents:
 
 * Canvas 2D's proposed [Canvas Floating Point Color Values](https://github.com/w3c/ColorWeb-CG/blob/main/canvas_float.md) allows for
   specifying higher bit depth canvas and ImageData.
@@ -134,22 +135,20 @@ As implied by its names, HDR imagery requires more then 8 bits per component. Pr
 [The WebGPU ``GPUCanvasConfiguration``](https://www.w3.org/TR/webgpu/#canvas-configuration) already allows 16-bit float values and
 can be further extended if needs be.
 
-### Extend the existing `srgb` color space for HDR imagery
+### Extend existing `PredefinedColorSpace` color spaces for HDR imagery
 
 Define a *screen's native linear color space* to be the color space with color primaries and white point set to the screen's
 `ScreenDetailed`'s `colorVolume` and the identity as its transfer function.
 
-A color is said to be within a screen's *default* range if, when that color is converted to the screen's native linear color space
-(using relative colorimetric intent), all of its color components are within the `[0, 1]` interval. When displaying content produced
-by a rendering context with `CanvasHighDynamicRangeMode` set to `'default'`, all colors that are within the screen's default range
-must be displayed without any clamping or roll-offs (neither in chrominance nor luminance).
+A color is said to be within a *screen's default range* if, when that color is converted to the *screen's native linear color
+space*, all of its color components are within the `[0, 1]` interval. When displaying content produced by a rendering context with
+`CanvasHighDynamicRangeMode` set to `'default'`, all colors that are within the *screen's default range* must not be gamut-mapped;
+other colors may be clipped or subject to screen-specific behavior.
 
-A color is said to be within a screen's *extended* range if, when that color is converted to the screen's native linear color space
-(using relative colorimetric intent), all of its color components are within the `[0, highDynamicRangeHeadroom]` interval. When
-displaying content produced by a rendering context with `CanvasHighDynamicRangeMode` set to `'extended'`, all colors that are within
-the screen's extended range must be displayed without any clamping or roll-offs (neither in chrominance nor luminance).
-
-Colors that do not fall under this guarantee should be clamped to the indicated range during display, but may be subject to screen-specific behavior.
+A color is said to be within a screen's *extended range* if, when that color is converted to the *screen's native linear color
+space*, all of its color components are within the `[0, highDynamicRangeHeadroom]` interval. When displaying content produced by a
+rendering context with `CanvasHighDynamicRangeMode` set to `'extended'`, all colors that are within the *screen's extended range*
+must not be gamut-mapped; other colors may be clipped or subject to screen-specific behavior.
 
 ### New HDR-specific color spaces
 
@@ -159,36 +158,17 @@ Update `PredefinedColorSpace` to include the following color spaces.
 
 ```idl
   partial enum PredefinedColorSpace {
-    'srgb-linear',
     'rec2100-hlg',
     'rec2100-pq',
   }
 ```
 
-As illustrated below, the proposal assumes that tone mapping, i.e. the rendering of an image with a given dynamic range onto a
-display with different dynamic range, occurs in different parts of the system depending on the color space of the Canvas element:
-
-* in the case where `rec2100-pq` are used, tone mapping is performed by the platform. This is akin to the scenario where the `src`
-  of an `img` element is a PQ image.
-
-* in the case where `rec2100-hlg` are used, tone mapping is performed by the display device. This is akin to the scenario where the
-  `src` of an `img` element is an HLG image.
-
-* in the case where any other color space is used (e.g, `srgb` or `srgb-linear`) tone mapping is performed by the web app, using
-  display capabilities provided by the platform.
+As illustrated below, the tone mapping of `rec2100-pq` and `rec2100-hlg` images, i.e. the rendering of an image with a given dynamic
+range onto a display with different dynamic range, is performed by the platform. This is akin to the scenario where the `src` of an
+`img` element is a PQ or HLG image.
 
 ![Tone mapping scenarios](./tone-mapping-scenarios.png)
 
-#### srgb-linear
-
-This color space uses the same primaries and white point as `srgb`, but with the identity function as the transfer function.
-
-```javascript
-  function electroOpticalTransferFunction(c) {
-    return c;
-  }
-```
-
 #### rec2100-hlg
 
 The component signals are mapped to red, green and blue tristimulus values according to the Hybrid Log-Gamma (HLG) system specified in Rec. ITU-R BT.2100.
@@ -205,7 +185,7 @@ In general, application should avoid conversions between color spaces and mainta
 between color spaces are not necessarily reversible and do not necessarily result in the same image appearance. In particular,
 conversion of an HDR image to an SDR will result in a signification loss of information and an SDR image that is different from the
 SDR image that would have been mastered from the same source material. From that perspective, converting from HDR to SDR imagery is
-no different than converting RGBA images to 16-color pallette images.
+similar to converting RGBA images to 16-color pallette images.
 
 Nevertheless, the HTML specification allows color space conversion in several scenarios, e.g., when [drawing images to a
 canvas](https://html.spec.whatwg.org/multipage/canvas.html#colour-spaces-and-colour-correction), [retrieving image data from a
@@ -224,150 +204,17 @@ These conversions fall into two broad categories:
 
 #### Between HDR color spaces
 
-##### General
-
-Conversions to and from extended `srgb` are not included since extended `srgb` is trivially converted to and from `srgb-linear`.
-
-Conversions between `rec2100-hlg` and `rec2100-pq` are implicitly specified through conversions to and from `srgb-linear`.
-
-The domain and range of the conversions consist of all real values.
-
-##### `rec2100-hlg` to `srgb-linear`
-
-_Input:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
-
-_Output:_ Full-range non-linear floating-point `srgb-linear` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
-
-_Process:_
-
-1. Apply HLG EOTF to convert the non-linear `rec2100-hlg` Signal to linear Pseudo-Display Light with Lw = 302 cd/m2 - See Note 1
-    * apply inverse HLG OETF
-    * apply HLG OOTF to derive linear display light
-2. Scale pixel values
-3. Convert from ITU BT.2100-1 color to SRGB color
-
-```javascript
-function convertREC2100HLGtoLinearSRGB(r, g, b) {
-  const systemGamma = 1.0;
-  const linearLightScaler = 1.0 / 0.26496256042100724;
-
-  const [r1, g1, b1] = hlg_inverse_oetf(r, g, b);
-  const [r2, g2, b2] = hlg_ootf(r1, g1, b1, systemGamma);
-
-  const r3 = linearLightScaler * r2;
-  const g3 = linearLightScaler * g2;
-  const b3 = linearLightScaler * b2;
-
-  const [r4, g4, b4] = matrixXYZtoSRGB(matrixBT2020toXYZ(r3, g3, b3));
-
-  return [r4, g4, b4];
-}
-```
-
-##### `srgb-linear` to `rec2100-hlg`
-
-_Input:_ Full-range non-linear floating-point `srgb-linear` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
-
-_Output:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
-
-_Process:_
-
-1. Convert from `extended-srgb-linear` color to `rec2100-hlg` color
-2. Scale pixel values - See Note 1
-3. Apply HLG Inverse EOTF to convert to HLG from Pseudo-Display Light with Lw = 302 cd/m2 - See Note 1
-    * apply HLG Inverse OOTF
-    * apply HLG OETF - See Note 2
-
-```javascript
-function convertLinearSRGBtoREC2100HLG(r, g, b) {
-  const systemGamma = 1.0;
-  const linearLightScaler = 0.26496256042100724;
-
-  const [r2, g2, b2] = matrixXYZtoBT2020(matrixSRGBtoXYZ(r1, g1, b1));
-
-  const r3 = linearLightScaler * r2;
-  const g3 = linearLightScaler * g2;
-  const b3 = linearLightScaler * b2;
-
-  const [r4, g4, b4] = hlg_inverse_ootf(r3, g3, b3, systemGamma);
-  const [r5, g5, b5] = hlg_oetf(r4, g4, b4);
-
-  return [r5, g5, b5];
-}
-```
-
-_Note 1:_ As `rec2100-hlg` is a relative format, the brightness of the virtual monitor used for mathematical transforms can be chosen to be any level. In this transform it is chosen to be 302 cd/m2 so that the brightness of diffuse white matches the diffuse white of sRGB (80 cd/m2). Using the extended range gamma formula in footnote 2 of BT.2100, this also sets the HLG Inverse OOTF to be unity. The value 0.265 is calculated by taking the inverse OETF of 0.75, the `rec2100-hlg` diffuse white level.
-
-_Note 2:_ See section 5.3 in ITU-R BT.2408-4 relating to negative transfer functions in format conversions.
-
-##### `srgb-linear` to `rec2100-pq`
-
-_Input:_ Full-range non-linear floating-point `srgb-linear` pixel. Values may exist outside the range 0.0 to 1.0.
-
-_Output:_ Full-range non-linear floating-point `rec2100-pq` pixel in the range 0.0 to 1.0.
-
-_Process:_
-
-1. Convert from sRGB color to Rec. ITU-R BT.2020 color
-2. Apply PQ Inverse EOTF, mapping such that a luminance of 203 cd/m<sup>2</sup> results in a value 1.0 in `srgb-linear`.
-
-```javascript
-function convertLinearSRGBtoREC2100PQ(r, g, b) {
-
-  const p2 = matrixXYZtoBT2020(matrixSRGBtoXYZ(r, g, b));
-
-  const k = 203;
-
-  let p3 = []
-  for (let i = 0; i < 3; i++) {
-
-    if (p2[i] < 0)
-      p3[i] = 0;
-    else if (p2[i] <= 10000/k) {
-      p3[i] = pqInverseEOTF(k * p2[i]);
-    else
-      p3[i] = 1.0;
-  }
-
-  return p3;
-}
-```
-
-##### `rec2100-pq` to `srgb-linear`
-
-_Input:_ Full-range non-linear floating-point `rec2100-pq` pixel in the range 0.0 to 1.0.
-
-_Output:_ Full-range non-linear floating-point `srgb-linear` pixel. Values may exist outside the range 0.0 to 1.0.
-
-_Process:_
-
-1. Apply PQ Inverse EOTF, mapping such that a luminance of 203 cd/m<sup>2</sup> results in a value 1.0 in `srgb-linear`.
-2. Convert from Rec. ITU-R BT.2020 color to sRGB color
-
-```javascript
-function convertREC2100PQToLinearSRGB(r, g, b) {
-
-  const k = 203;
-
-  const r3 = pqEOTF(r) / k;
-  const g3 = pqEOTF(g) / k;
-  const b3 = pqEOTF(b) / k;
-
-  return matrixXYZtoSRGB(matrixBT2020toXYZ(r3, g3, b3));
-}
-```
+The conversion between `rec2100-pq` and `rec2100-hlg` is specified at [Report ITU-R BT.2408-5, Clause 6](https://www.itu.int/pub/R-REP-BT.2408),
 
 #### Between SDR and HDR color spaces
 
 ##### General
 
-Conversions to and from `srgb` are provided for `rec2100-pq` and `rec2100-hlg` color spaces. Extended `srgb` images can be converted
-for display on an sRGB monitor by first converting to `rec2100-pq` and `rec2100-hlg` first and then applying the relevant conversion
-to `srgb`.
+Conversions to and from `srgb` are provided for `rec2100-pq` and `rec2100-hlg` color spaces.
 
 ##### `rec2100-pq` to `srgb`
 
-See Annex B at SMPTE ST 2094-10.
+Tone mapping from `rec2100-pq` to `srgb` is specified at [SMPTE ST 2094-10, Annex B](https://ieeexplore.ieee.org/document/7513370).
 
 ##### `rec2100-hlg` to `srgb`
 
@@ -384,21 +231,21 @@ _Note 3_ This transform utilises the backwards compatibility of ITU-R BT.2100 HL
 
 ```javascript
 
-function simpleTransform(value, systemGamma) { 
-  if (value < 1.0) { 
-    return -1.0 * Math.pow(-1.0 * value, systemGamma); 
-  } else { 
-    return Math.pow(value, systemGamma); 
+function simpleTransform(value, systemGamma) {
+  if (value < 1.0) {
+    return -1.0 * Math.pow(-1.0 * value, systemGamma);
+  } else {
+    return Math.pow(value, systemGamma);
   } 
 }
 
-function simpleInverseTransform(value, systemGamma) { 
-  if (value < 1.0) { 
-    return -1.0 * Math.pow(-1.0 * value, 1.0 / systemGamma); 
-  } else { 
-    return Math.pow(value, 1.0 / systemGamma); 
-  } 
-} 
+function simpleInverseTransform(value, systemGamma) {
+  if (value < 1.0) {
+    return -1.0 * Math.pow(-1.0 * value, 1.0 / systemGamma);
+  } else {
+    return Math.pow(value, 1.0 / systemGamma);
+  }
+}
 
 function tonemapREC2100HLGtoSRGBdisplay(r, g, b) {
   const systemGamma = 2.2;
@@ -406,9 +253,9 @@ function tonemapREC2100HLGtoSRGBdisplay(r, g, b) {
   const g1 = simpleTransform(g, systemGamma);
   const b1 = simpleTransform(b, systemGamma);
   const [r2, g2, b2] = matrixXYZtoSRGB(matrixBT2020toXYZ(r1, g1, b1));
-  const r3 = simpleInverseTransform(r2, systemGamma);      
-  const g3 = simpleInverseTransform(g2, systemGamma); 
-  const b3 = simpleInverseTransform(b2, systemGamma); 
+  const r3 = simpleInverseTransform(r2, systemGamma);
+  const g3 = simpleInverseTransform(g2, systemGamma);
+  const b3 = simpleInverseTransform(b2, systemGamma);
   const [r4, g4, b4] = limitTosRGBGamut(r3, g3, b3);
   return [r4, g4, b4];
 }
@@ -431,31 +278,41 @@ The compositing behavior of an `HTMLCanvasElement` may be specified via the `Can
 This section describes the default compositing behavior for canvas element.
 This is the behavior that happens if the `CanvasColorMetadata` is not set, or if is called specifying `'default'` as the mode.
 
-In this mode, the `HTMLCanvasElement` will be composited exactly as an `<img>` or `<video>` element with a source in the canvas' color space would be composited.
+In this mode, the `HTMLCanvasElement` will be composited exactly as an `<img>` or `<video>` element with a source in the canvas'
+color space would be composited.
 
-This means that if the canvas' color space is `'rec2100-hlg'` or `'rec2100-pq'`, then the canvas will be composited using high dynamic range, where available.
+This means that if the canvas' color space is `'rec2100-hlg'` or `'rec2100-pq'`, then the canvas will be composited using high
+dynamic range, where available.
 
-Note that if the canvas' color space is `'srgb-linear'` or `'srgb'`, then the canvas will not be composited using high dynamic range. Pixel values outside of the [0, 1] interval will extend the displayed gamut beyond sRGB, but not the displayed luminance beyond the maximum SDR luminance.
+Otherwise, e.g. if the canvas' color space is `'srgb-linear'` or `'srgb'`, the canvas will not be composited using high dynamic
+range. Pixel values outside of the [0, 1] interval will extend the displayed gamut beyond sRGB, but not the displayed luminance
+beyond the maximum SDR luminance.
 
-Performing appropriate tone mapping is the responsibility of the browser, the operating system, and the display device.
-If the `CanvasColorMetadata` is set to specify metadata and the canvas' color space is `'rec2100-pq'`, then this metadata will be interpreted during compositing in the same way that it would be interpreted if included in a source displayed via an `<img>` or `<video>` element.
+Performing appropriate tone mapping is the responsibility of the browser, the operating system, and the display device. If the
+`CanvasColorMetadata` is set to specify metadata and the canvas' color space is `'rec2100-pq'`, then this metadata will be
+interpreted during compositing in the same way that it would be interpreted if included in a source displayed via an `<img>` or
+`<video>` element.
 
 #### Extended mode
 
-If the canvas' color space is `'srgb-linear'` or `'srgb'`, then pixels values outside of the [0, 1] interval will extend the displayed luminance beyond the maximum SDR luminance.
+If the canvas' color space is `'srgb-linear'` or `'srgb'`, then pixels values outside of the [0, 1] interval will extend the
+displayed luminance beyond the maximum SDR luminance.
 
-It is guaranteed that SDR colors in this mode exactly match SDR colors in non-HDR content on the page.
-For example, a canvas pixel value of `'(1,0,0)'` in `'srgb'` is guaranteed to match the CSS color `'red'`.
+It is guaranteed that SDR colors in this mode exactly match SDR colors in non-HDR content on the page. For example, a canvas pixel
+value of `'(1,0,0)'` in `'srgb'` is guaranteed to match the CSS color `'red'`.
 
-Performing appropriate tone mapping is the responsibility of the browser, the operating system, and the display device.
-If the `CanvasColorMetadata` specifies a maximum luminance that is greater than the display's luminance, then tone mapping will be applied to prevent clipping of luminance values below to the specified maximum luminance.
-Note that the tone mapping algorithm may not alter any SDR color values (otherwise the SDR color matching guarantee would be violated).
+Performing appropriate tone mapping is the responsibility of the browser, the operating system, and the display device. If the
+`CanvasColorMetadata` specifies a maximum luminance that is greater than the display's luminance, then tone mapping will be applied
+to prevent clipping of luminance values below to the specified maximum luminance. Note that the tone mapping algorithm may not alter
+any SDR color values (otherwise the SDR color matching guarantee would be violated).
 
 ## Privacy considerations
 
-The precise capabilities of the output display, such as the exact color gamut and the precise maximum luminance values, are fingerprinting vectors, and should not be exposed to the application without user permission.
+The precise capabilities of the output display, such as the exact color gamut and the precise maximum luminance values, are
+fingerprinting vectors, and should not be exposed to the application without user permission.
 
-Access to these values is protected behind the same permission prompt that protects other screen capability fingerprinting vectors in the [window placement proposal](https://github.com/webscreens/window-placement/blob/main/EXPLAINER.md).
+Access to these values is protected behind the same permission prompt that protects other screen capability fingerprinting vectors
+in the [window placement proposal](https://github.com/webscreens/window-placement/blob/main/EXPLAINER.md).
 
 ## Example Applications
 

From 0269ed12383c89a4efbf8d11c81e31e57cf28e4a Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Thu, 23 Feb 2023 23:13:41 -0800
Subject: [PATCH 05/18] Simplify strawman

---
 hdr_html_canvas_element.md | 558 +++++++++++++++----------------------
 tone-mapping-scenarios.png | Bin 16022 -> 9825 bytes
 2 files changed, 225 insertions(+), 333 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index fb4388a..9ab283c 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -1,35 +1,52 @@
-# High Dynamic Range (HDR) HTML Canvas
+# Adding support High Dynamic Range (HDR) imagery to HTML Canvas
 
-## Scope
+## Introduction
+
+Today [HTML
+Canvas](https://html.spec.whatwg.org/multipage/canvas.html#imagedata) supports
+only 8 bit per color channel and two `PredefinedColorSpace` color spaces (`srgb`
+and `display-p3`).
+
+This is insufficient for High-Dynamic Range (HDR) imagery, which is in
+widespread use today:
 
-We propose to extend the HTML Canvas API to support High Dynamic Range (HDR) imagery.
+* As detailed, for example, at [Ultra HD Blu-ray Format Video Characteristics
+](https://ieeexplore.ieee.org/document/7514362), 8-bit quantization (bit depth)
+results in contouring and banding, even for traditional standard dynamic range
+(SDR) imagery, like sRGB, which covers a typical luminance range between 0 and
+100 cd/m<sup>2</sup>. These quantization artifacts become unacceptable with
+High-Dynamic Range (HDR) imagery, supports luminance ranges between 0 and up to
+10,000 cd/m<sup>2</sup>.
 
-## Primary requirements
+* As specified at [Rec. ITU-R BT.2100](https://www.itu.int/rec/R-REC-BT.2100),
+two color spaces tailored for HDR imagery have developed: BT.2100 PQ and BT.2100
+HLG.
 
-* Minimum performance overhead
-* Draw SDR content in an HDR canvas with the result being identical  the same SDR content had been drawn in an SDR canvas
-* Draw Standard Dynamic Range (SDR) images such that these images appear as they would if displayed in an `<img>` tag
-* Draw IUT-R BT.2100 Hybrid Log-Gamma (HLG) encoded (HDR) images such that these images appear as they would if displayed via an
-  `<img>` or `<video>` tag
-* Draw IUT-R BT.2100 Perceptual Quantiser (PQ) encoded (HDR) images such that these images appear as they would if displayed via an
-  `<img>` or `<video>` tag
+* To render HDR imagery, it is useful to have information on the luminance range
+and color gamut that (a) are supported by the display and (b) were used when
+authoring the image.
 
-## Summary
+Accordingly, the following API modifications are needed to manipulate HDR images
+in HTML Canvas:
 
-We propose to introduce:
+1. add the ability to query the luminance range and color gamut of the display
+2. add BT.2100 PQ and BT.2100 HLG color spaces to `PredefinedColorSpace`
+3. add higher bit depth capabilities to `CanvasRenderingContext2DSettings`
+4. add higher bit depth capabilities to `ImageDataSettings`
+5. add luminance and color gamut information to `ImageDataSettings` and
+   `CanvasRenderingContext2DSettings`
+
+## Scope
 
-* two new color spaces: `rec2100-hlg`, `rec2100-pq`
-* define new HDR semantics for existing `PredefinedColorSpace` color spaces
-* color metadata relevant to HDR rendering to the `HTMLCanvasElement`'s rendering context.
-* screen parameters relevant to HDR rendering using the `ScreenAdvanced` interface
-* fallback reference conversions between HDR color spaces
-* fallback reference conversion between SDR and HDR color spaces
+We propose to extend the Web Platform to allow the HTML Canvas API to manipulate
+High Dynamic Range (HDR) images.
 
-## Proposal
+## Add the ability to query the luminance range and color gamut of the display
 
 ### Querying screen HDR parameters
 
-Add a new attribute to `ScreenAdvanced` to indicate the HDR headroom currently available on the screen.
+Add a new attribute to `ScreenAdvanced` to indicate the HDR headroom currently
+available on the screen.
 
 ```idl
   partial interface ScreenAdvanced {
@@ -40,11 +57,10 @@ Add a new attribute to `ScreenAdvanced` to indicate the HDR headroom currently a
   }
 ```
 
-See below for more details on the display of floating point color values.
-
 ### Querying screen wide color gamut parameters
 
-Add new attributes to `ScreenDetailed` to indicate the gamut and white point of the screen.
+Add new attributes to `ScreenDetailed` to indicate the gamut and white point of
+the screen.
 
 ```idl
   partial interface ScreenDetailed {
@@ -53,14 +69,10 @@ Add new attributes to `ScreenDetailed` to indicate the gamut and white point of
   }
 ```
 
-### Color volume structure
-
-Add a new color volume structure for use in several places.
-
 ```idl
   dictionary ColorVolume {
     // The color primaries and white point of a color volume, in CIE 1931 xy
-    // coordinates. 
+    // coordinates.
     required double redPrimaryX;
     required double redPrimaryY;
     required double greenPrimaryX;
@@ -72,126 +84,163 @@ Add a new color volume structure for use in several places.
   }
 ```
 
-### Enabling HDR on a canvas element's rendering context
+## Add color spaces intended for use with HDR imagery
 
-Add a new `CanvasColorMetadata` dictionary with HDR configuration options.
+### General
+
+Extend `PredefinedColorSpace` to include the following color spaces.
 
 ```idl
-  dictionary CanvasColorMetadata {
-    CanvasHighDynamicRangeMode mode = 'default';
-    CanvasSmpteSt2086Metadata smpteSt2086Metadata;
+  partial enum PredefinedColorSpace {
+    'rec2100-hlg',
+    'rec2100-pq',
+    'linear-srgb'
   }
+```
 
-  enum CanvasHighDynamicRangeMode {
-    // The default behavior. Enables HDR for 'rec2100-hlg' and 'rec2100-pq'
-    // color spaces only.
-    'default',
+As illustrated below, the tone mapping of `rec2100-pq` and `rec2100-hlg` images,
+i.e. the rendering of an image with a given dynamic range onto a display with
+different dynamic range, is performed by the platform. This is akin to the
+scenario where the `src` of an `img` element is a PQ or HLG image.
 
-    // Enables extended luminance while preserving SDR color matching.
-    'extended',
-  }
+![Tone mapping scenarios](./tone-mapping-scenarios.png)
 
-  // SMPTE ST 2086 color volume metadata.
-  dictionary CanvasSmpteSt2086Metadata {
-    ColorVolume colorVolume;
-    required float minimumLuminanceNits;
-    required float maximumLuminanceNits;
-  }
-```
+Conversions to and from `rec2100-pq` and `rec2100-hlg` are detailed in Annex A
+below.
 
-Add a mechanism for specifying this on `CanvasRenderingContext2D`, `OffscreenCanvasRenderingContext2D`, `WebGLRenderingContextBase`, and `GPUCanvasContext`.
+Extending `PredefinedColorSpace` automatically extends
+`CanvasRenderingContext2DSettings` and `ImageDataSettings`.
 
-For 2D canvas this would be:
-```idl
-  partial interface CanvasRenderingContext2D/OffscreenCanvasRenderingContext2D {
-    attribute CanvasColorMetadata colorMetadata;
-  }
-```
+### rec2100-hlg
 
-For WebGL this would be:
-```idl
-  partial interface WebGLRenderingContextBase {
-    attribute CanvasColorMetadata drawingBufferColorMetadata;
-  }
-```
+The component signals are mapped to red, green and blue tristimulus values
+according to the Hybrid Log-Gamma (HLG) system specified in Rec. ITU-R BT.2100.
 
-For WebGPU this would be:
-```idl
-  partial interface GPUCanvasContext {
-    attribute CanvasColorMetadata colorMetadata;
-  }
-```
+### rec2100-pq
 
-### Pixel bit depths greater than 8 bits for Canvas, WebGL and WebGPU
+The component signals are mapped to red, green and blue tristimulus values
+according to the Perceptual Quantizer (PQ) system system specified in Rec. ITU-R
+BT.2100.
 
-As implied by its names, HDR imagery benefits from more then 8 bits per component. Proposals to extend the HTML Canvas API and WebGL
-APIs are covered in other documents:
+### linear-srgb
 
-* Canvas 2D's proposed [Canvas Floating Point Color Values](https://github.com/w3c/ColorWeb-CG/blob/main/canvas_float.md) allows for
-  specifying higher bit depth canvas and ImageData.
-* WebGL's proposed [``drawingBufferStorage``](https://github.com/KhronosGroup/WebGL/pull/3222) function allows for specifying higher
-  bit depth formats.
+`linear-srgb` is specified in CSS Color 4 and is useful for physics-based
+rendering of HDR scenes.
 
-[The WebGPU ``GPUCanvasConfiguration``](https://www.w3.org/TR/webgpu/#canvas-configuration) already allows 16-bit float values and
-can be further extended if needs be.
+### Extend `CanvasRenderingContext2DSettings` to support higher bit depths
 
-### Extend existing `PredefinedColorSpace` color spaces for HDR imagery
+Add to `CanvasRenderingContext2DSettings` a `CanvasColorType` member that
+specifies the representation of each pixel of the _output bitmap_ of a
+`CanvasRenderingContext2D` and `OffscreenCanvasRenderingContext2D`.
 
-Define a *screen's native linear color space* to be the color space with color primaries and white point set to the screen's
-`ScreenDetailed`'s `colorVolume` and the identity as its transfer function.
+```idl
+  partial dictionary CanvasRenderingContext2DSettings {
+    CanvasColorType colorType = "unorm8";
+  };
+```
 
-A color is said to be within a *screen's default range* if, when that color is converted to the *screen's native linear color
-space*, all of its color components are within the `[0, 1]` interval. When displaying content produced by a rendering context with
-`CanvasHighDynamicRangeMode` set to `'default'`, all colors that are within the *screen's default range* must not be gamut-mapped;
-other colors may be clipped or subject to screen-specific behavior.
+```idl
+  enum CanvasColorType {
+    "unorm8",
+    "float16",
+  };
+```
 
-A color is said to be within a screen's *extended range* if, when that color is converted to the *screen's native linear color
-space*, all of its color components are within the `[0, highDynamicRangeHeadroom]` interval. When displaying content produced by a
-rendering context with `CanvasHighDynamicRangeMode` set to `'extended'`, all colors that are within the *screen's extended range*
-must not be gamut-mapped; other colors may be clipped or subject to screen-specific behavior.
+`colorType = "unorm8"` corresponds to HTML Canvas as it exists today.
 
-### New HDR-specific color spaces
+### Extend `ImageDataSettings` to support higher bit depths
 
-#### General
+Add to `ImageDataSettings` a `ImageDataColorType` member that specifies the type
+of the `data` member of `ImageData`.
 
-Update `PredefinedColorSpace` to include the following color spaces.
+```idl
+  partial dictionary ImageDataSettings {
+    ImageDataColorType colorType = "Uint8ClampedArray";
+  };
+```
 
 ```idl
-  partial enum PredefinedColorSpace {
-    'rec2100-hlg',
-    'rec2100-pq',
-  }
+  enum ImageDataColorType {
+    "Uint8ClampedArray",
+    "Float16Array",
+    "Float32Array"
+    // and potentially others
+  };
 ```
 
-As illustrated below, the tone mapping of `rec2100-pq` and `rec2100-hlg` images, i.e. the rendering of an image with a given dynamic
-range onto a display with different dynamic range, is performed by the platform. This is akin to the scenario where the `src` of an
-`img` element is a PQ or HLG image.
+## Add luminance and color gamut information to `ImageDataSettings` and `CanvasRenderingContext2DSettings`
 
-![Tone mapping scenarios](./tone-mapping-scenarios.png)
+Add a new CanvasColorMetadata dictionary:
+
+  dictionary CanvasColorMetadata {
+    CanvasHighDynamicRangeMode mode = 'default';
+    CanvasSmpteSt2086Metadata smpteSt2086Metadata;
+  }
 
-#### rec2100-hlg
+  enum CanvasHighDynamicRangeMode {
+    // The default behavior.
+    // HDR is enabled for 'rec2100-hlg' and 'rec2100-pq' color spaces only.
+    'default',
+    // HDR is enabled for all color spaces
+    'extended',
+  }
 
-The component signals are mapped to red, green and blue tristimulus values according to the Hybrid Log-Gamma (HLG) system specified in Rec. ITU-R BT.2100.
+  // SMPTE ST 2086 color volume metadata.
+  dictionary CanvasSmpteSt2086Metadata {
+    ColorVolume colorVolume;
+    required float minimumLuminanceNits;
+    required float maximumLuminanceNits;
+  }
 
-#### rec2100-pq
+Add a mechanism for specifying this on `CanvasRenderingContext2D` and
+`OffscreenCanvasRenderingContext2D`.
 
-The component signals are mapped to red, green and blue tristimulus values according to the Perceptual Quantizer (PQ) system system specified in Rec. ITU-R BT.2100.
+  partial interface CanvasRenderingContext2D/OffscreenCanvasRenderingContext2D {
+    attribute CanvasColorMetadata colorMetadata;
+  }
 
-### Color space conversions
+The semantics of `CanvasHighDynamicRangeMode` are as follows:
 
-#### Background
+* Define a *screen's native linear color space* to be the color space with color
+primaries and white point set to the screen's `ScreenDetailed`'s `colorVolume`
+and the identity as its transfer function.
 
-In general, application should avoid conversions between color spaces and maintain imagery in its original color space: conversions
-between color spaces are not necessarily reversible and do not necessarily result in the same image appearance. In particular,
-conversion of an HDR image to an SDR will result in a signification loss of information and an SDR image that is different from the
-SDR image that would have been mastered from the same source material. From that perspective, converting from HDR to SDR imagery is
-similar to converting RGBA images to 16-color pallette images.
+* A color is said to be within a *screen's default range* if, when that color is
+converted to the *screen's native linear color space*, all of its color
+components are within the `[0, 1]` interval. When displaying content produced by
+a rendering context with `CanvasHighDynamicRangeMode` set to `'default'`, all
+colors that are within the *screen's default range* must not be gamut-mapped;
+other colors may be clipped or subject to screen-specific behavior.
 
-Nevertheless, the HTML specification allows color space conversion in several scenarios, e.g., when [drawing images to a
-canvas](https://html.spec.whatwg.org/multipage/canvas.html#colour-spaces-and-colour-correction), [retrieving image data from a
-canvas](https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-getimagedata), among others being added). The conversions
-between predefined SDR color spaces are defined at <https://www.w3.org/TR/css-color-4/>, and this proposal similarly defines
-conversions for HDR color spaces.
+* A color is said to be within a screen's *extended range* if, when that color
+is converted to the *screen's native linear color space*, all of its color
+components are within the `[0, highDynamicRangeHeadroom]` interval. When
+displaying content produced by a rendering context with
+`CanvasHighDynamicRangeMode` set to `'extended'`, all colors that are within the
+*screen's extended range* must not be gamut-mapped; other colors may be clipped
+or subject to screen-specific behavior.
+
+## Annex A: Color space conversions
+
+### Background
+
+In general, application should avoid conversions between color spaces and
+maintain imagery in its original color space: conversions between color spaces
+are not necessarily reversible and do not necessarily result in the same image
+appearance. In particular, conversion of an HDR image to an SDR will result in a
+signification loss of information and an SDR image that is different from the
+SDR image that would have been mastered from the same source material. From that
+perspective, converting from HDR to SDR imagery is similar to converting RGBA
+images to 16-color pallette images.
+
+Nevertheless, the HTML specification allows color space conversion in several
+scenarios, e.g., when [drawing images to a
+canvas](https://html.spec.whatwg.org/multipage/canvas.html#colour-spaces-and-colour-correction),
+[retrieving image data from a
+canvas](https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-getimagedata),
+among others being added). The conversions between predefined SDR color spaces
+are defined at <https://www.w3.org/TR/css-color-4/>, and this proposal similarly
+defines conversions for HDR color spaces.
 
 The following illustrates the conversions that are explicitly specified:
 
@@ -202,32 +251,40 @@ These conversions fall into two broad categories:
 * conversion between HDR color spaces
 * conversion between an HDR and an SDR color space (tone mapping)
 
-#### Between HDR color spaces
+### Between HDR color spaces
 
-The conversion between `rec2100-pq` and `rec2100-hlg` is specified at [Report ITU-R BT.2408-5, Clause 6](https://www.itu.int/pub/R-REP-BT.2408),
+The conversion between `rec2100-pq` and `rec2100-hlg` is specified at [Report
+ITU-R BT.2408-5, Clause 6](https://www.itu.int/pub/R-REP-BT.2408),
 
-#### Between SDR and HDR color spaces
+### Between SDR and HDR color spaces
 
-##### General
+#### General
 
 Conversions to and from `srgb` are provided for `rec2100-pq` and `rec2100-hlg` color spaces.
 
-##### `rec2100-pq` to `srgb`
+#### `rec2100-pq` to `srgb`
 
-Tone mapping from `rec2100-pq` to `srgb` is specified at [SMPTE ST 2094-10, Annex B](https://ieeexplore.ieee.org/document/7513370).
+Tone mapping from `rec2100-pq` to `srgb` is specified at [SMPTE ST 2094-10,
+Annex B](https://ieeexplore.ieee.org/document/7513370).
 
-##### `rec2100-hlg` to `srgb`
+#### `rec2100-hlg` to `srgb`
 
-_Input:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at 0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
+_Input:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at
+0.0 and diffuse white at 0.75. Values may exist outside the range 0.0 to 1.0.
 
-_Output:_ Full-range non-linear floating-point `srgb` pixel with black at 0.0 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
+_Output:_ Full-range non-linear floating-point `srgb` pixel with black at 0.0
+and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
 
 _Process:_
-  1. Pseudo-linearize the HLG signal exploiting its backwards compatibility with SDR consumer displays
+  1. Pseudo-linearize the HLG signal exploiting its backwards compatibility with
+     SDR consumer displays
   2. Convert from ITU BT.2100 color space to sRGB color space
   3. Convert back to non-linear using a reciprocal transform
 
-_Note 3_ This transform utilises the backwards compatibility of ITU-R BT.2100 HLG HDR with consumer electronic displays.  Prior to display, the gamut may need to be limited to the range 0-1.  The simplest method is to clip values but other gamut reduction techniques may provide better output images.
+_Note 3_ This transform utilises the backwards compatibility of ITU-R BT.2100
+HLG HDR with consumer electronic displays.  Prior to display, the gamut may need
+to be limited to the range 0-1.  The simplest method is to clip values but other
+gamut reduction techniques may provide better output images.
 
 ```javascript
 
@@ -261,224 +318,59 @@ function tonemapREC2100HLGtoSRGBdisplay(r, g, b) {
 }
 ```
 
-##### `srgb` to `rec2100-hlg`
+#### `srgb` to `rec2100-hlg`
 
-See [TTML 2, Annex Q.2, steps 1-8](https://www.w3.org/TR/ttml2/#hlg-hdr) with `tts:luminanceGain = 203/80`.
+See [TTML 2, Annex Q.2, steps 1-8](https://www.w3.org/TR/ttml2/#hlg-hdr) with
+`tts:luminanceGain = 203/80`.
 
-##### `srgb` to `rec2100-pq`
+#### `srgb` to `rec2100-pq`
 
 See [TTML 2, Annex Q.1, steps 1-8](https://www.w3.org/TR/ttml2/#hdr-compositing).
 
-### Compositing the HDR `HTMLCanvasElement`
+## Annex B: Compositing the HDR `HTMLCanvasElement`
 
-The compositing behavior of an `HTMLCanvasElement` may be specified via the `CanvasColorMetadata` attribute of its rendering context.
+The compositing behavior of an `HTMLCanvasElement` may be specified via the
+`CanvasColorMetadata` attribute of its rendering context.
 
-#### Default behavior
+### Default behavior
 
-This section describes the default compositing behavior for canvas element.
-This is the behavior that happens if the `CanvasColorMetadata` is not set, or if is called specifying `'default'` as the mode.
+This section describes the default compositing behavior for canvas element. This
+is the behavior that happens if the `CanvasColorMetadata` is not set, or if is
+called specifying `'default'` as the mode.
 
-In this mode, the `HTMLCanvasElement` will be composited exactly as an `<img>` or `<video>` element with a source in the canvas'
-color space would be composited.
+In this mode, the `HTMLCanvasElement` will be composited exactly as an `<img>`
+or `<video>` element with a source in the canvas' color space would be
+composited.
 
-This means that if the canvas' color space is `'rec2100-hlg'` or `'rec2100-pq'`, then the canvas will be composited using high
-dynamic range, where available.
+This means that if the canvas' color space is `'rec2100-hlg'` or `'rec2100-pq'`,
+then the canvas will be composited using high dynamic range, where available.
 
-Otherwise, e.g. if the canvas' color space is `'srgb-linear'` or `'srgb'`, the canvas will not be composited using high dynamic
-range. Pixel values outside of the [0, 1] interval will extend the displayed gamut beyond sRGB, but not the displayed luminance
-beyond the maximum SDR luminance.
-
-Performing appropriate tone mapping is the responsibility of the browser, the operating system, and the display device. If the
-`CanvasColorMetadata` is set to specify metadata and the canvas' color space is `'rec2100-pq'`, then this metadata will be
-interpreted during compositing in the same way that it would be interpreted if included in a source displayed via an `<img>` or
-`<video>` element.
-
-#### Extended mode
-
-If the canvas' color space is `'srgb-linear'` or `'srgb'`, then pixels values outside of the [0, 1] interval will extend the
+Otherwise, e.g. if the canvas' color space is `'srgb-linear'` or `'srgb'`, the
+canvas will not be composited using high dynamic range. Pixel values outside of
+the [0, 1] interval will extend the displayed gamut beyond sRGB, but not the
 displayed luminance beyond the maximum SDR luminance.
 
-It is guaranteed that SDR colors in this mode exactly match SDR colors in non-HDR content on the page. For example, a canvas pixel
-value of `'(1,0,0)'` in `'srgb'` is guaranteed to match the CSS color `'red'`.
-
-Performing appropriate tone mapping is the responsibility of the browser, the operating system, and the display device. If the
-`CanvasColorMetadata` specifies a maximum luminance that is greater than the display's luminance, then tone mapping will be applied
-to prevent clipping of luminance values below to the specified maximum luminance. Note that the tone mapping algorithm may not alter
-any SDR color values (otherwise the SDR color matching guarantee would be violated).
-
-## Privacy considerations
-
-The precise capabilities of the output display, such as the exact color gamut and the precise maximum luminance values, are
-fingerprinting vectors, and should not be exposed to the application without user permission.
-
-Access to these values is protected behind the same permission prompt that protects other screen capability fingerprinting vectors
-in the [window placement proposal](https://github.com/webscreens/window-placement/blob/main/EXPLAINER.md).
-
-## Example Applications
-
-### Detecting HDR capabilities
-
-The `getScreens` method will prompt the user for permission to reveal fingerprintable information.
-
-```javascript
-  let screens = await window.getScreens();
-  console.log('HDR headroom: ' + currentScreen.highDynamicRangeHeadroom);
-```
-
-If `getScreens` is denied, then media queries may be used to determine the screen's capabilities, at a high level.
-
-```javascript
-  let hasHighDynamicRange = window.matchMedia('(dynamic-range: high)').matches;
-  console.log('HDR capable: ' + hasHighDynamicRange);
-```
-
-### The `srgb-linear` color space
-
-#### WebGL using extended mode
-
-In this example, a WebGL application enables and HDR default drawing buffer, and clears it to the pixel value `(1,1,1,1)`.
-
-```javascript
-    var canvas = document.getElementById('MyCanvas');
-
-    var gl = canvas.getContext('webgl2');
-    gl.drawingBufferStorage(gl.RGBA16F, canvas.width, canvas.height);
-    gl.drawingBufferColorMetadata = {mode:'extended'};
-    gl.colorSpace = 'srgb-linear';
-    gl.clearColor(1.0, 1.0, 1.0, 1.0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-```
-
-When composited, this canvas is guaranteed to be the same color as the CSS color `'white'`.
-
-### The `rec2100-hlg` color space
-
-#### Displaying an HLG image in an SDR 2D canvas
-
-In this example, we use an SDR 2D canvas to display a HLG image.
-This image will map into the SDR range without clipping.
-
-```javascript
-    var canvas = document.getElementById('MyCanvas');
-    var context = canvas.getContext('2d');
-
-    var image = new Image();
-    image.onload = function() {
-      context.drawImage(image, 0, 0, image.width, image.height);
-    }
-    var url = 'https://storage.googleapis.com/dalecurtis/cosmos_hlg.avif';
-    image.src = url;
-```
-
-#### Displaying an HLG image in an HLG 2D canvas
-
-In this example, we use an HLG 2D canvas to display a HLG image.
-
-```javascript
-    var canvas = document.getElementById('MyCanvas');
-    var context = canvas.getContext('2d',
-        {colorSpace:'rec2100-hlg', storageFormat:'unorm-10-10-10-2'});
-
-    // Load and draw the image to the canvas.
-    var image = new Image();
-    image.onload = function() {
-      context.drawImage(image, 0, 0, image.width, image.height);
-    }
-    var url = 'https://storage.googleapis.com/dalecurtis/cosmos_hlg.avif';
-    image.src = url;
-```
-
-This canvas, when composited, will always be identical to displaying the image an ordinary `<img>` element.
-
-```xml
-  <img src='https://storage.googleapis.com/dalecurtis/cosmos_hlg.avif'/>
-```
-
-#### Adding subtitles to an HLG image
-
-Suppose we wish to change the above example to draw subtitles at a brightness that corresponds to an HLG signal value of 0.75.
-
-```javascript
-    var canvas = document.getElementById('MyCanvas');
-    var context = canvas.getContext('2d',
-        {colorSpace:'rec2100-hlg', storageFormat:'unorm-10-10-10-2'});
-
-    // Load and draw the image to the canvas.
-    var image = new Image();
-    image.onload = function() {
-      context.drawImage(image, 0, 0, image.width, image.height);
-
-      // Draw a subtitle!
-      context.fillStyle = 'color(rec2100-hlg 0.75  0.75 0.75)';
-      context.fillText('Hello, I am a subtitle!');
-    }
-    var url = 'https://storage.googleapis.com/dalecurtis/cosmos_hlg.avif';
-    image.src = url;
-```
-
-Note that this is identical to specifying the subtitle color in `'srgb-linear'`.
-
-```javascript
-    context.fillStyle = 'color(srgb-linear 0.265  0.265 0.265)';
-```
-
-### The `rec2100-pq` color space
-
-In this example, we use a PQ 2D canvas to display a PQ image.
-
-```javascript
-    var canvas = document.getElementById('MyCanvas');
-    var context = canvas.getContext('2d',
-        {colorSpace:'rec2100-pq', storageFormat:'unorm-10-10-10-2'});
-
-    // Load and draw the image to the canvas.
-    var image = new Image();
-    image.onload = function() {
-      context.drawImage(image, 0, 0, image.width, image.height);
-    }
-    var url = 'https://storage.googleapis.com/dalecurtis/cosmos_1000_pq_hdr.avif';
-    image.src = url;
-```
-
-There is no guarantee that this canvas, when composited, will be equivalent to displaying the image an ordinary `<img>` element.
-
-```xml
-  <img src='https://storage.googleapis.com/dalecurtis/cosmos_hlg.avif'/>
-```
-
-The reason this guarantee cannot be made is that the `<img>` element may do custom tonemapping based on embedded metadata.
-There does not exist any API for extracting this metadata from an `Image` object, and thus this metadata cannot be passed on to the `HTMLCanvasElement`.
-
-## Issues
-
-The above is a simplified version of the API that was proposed earlier.
-
-### HDR compositing independent of color space
-
-In the existing API, there is no way to have a linear space working space for an HLG or PQ canvas
-
-The fix for this that I propose is to allow a `'hlg'` and `'pq'` `CanvasHighDynamicRangeMode`.
-
-In that case, the code to work in a linearized HLG space would be:
-
-```javascript
-    var context = canvas.getContext('2d',
-        {colorSpace:'srgb-linear', storageFormat:'float-16'});
-    context.colorMetadata = {mode:'hlg'};
-```
-
-### ImageBitmap conversion options
-
-The `ImageBitmapOptions` structure already has `colorSpace` and `colorSpaceConversion` members.
-
-The `colorSpaceConversion` has `default`, which is relative colorimetric intent, and `none`, which is to simply reinterpret values directly.
-
-We could consider adding a `perceptual` option for `colorSpaceConversion`, which would perform some sort of tonemapping. We could also add a `bt2408` option.
-
-### Appropriate location for HDR configuration
-
-In this proposal, the HDR configuration data has been attached to the `HTMLCanvasElement`.
-Arguably, the HDR configuration data could be attached to the `CanvasRenderingContext2D` and `WebGLRenderingContextBase`.
-
-The HDR configuration data should travel with an `ImageBitmap` when displayed in an `ImageBitmapRenderingContext`.
-That may inform where we should put this.
+Performing appropriate tone mapping is the responsibility of the browser, the
+operating system, and the display device. If the `CanvasColorMetadata` is set to
+specify metadata and the canvas' color space is `'rec2100-pq'`, then this
+metadata will be interpreted during compositing in the same way that it would be
+interpreted if included in a source displayed via an `<img>` or `<video>`
+element.
+
+### Extended mode
+
+If the canvas' color space is `'srgb-linear'` or `'srgb'`, then pixels values
+outside of the [0, 1] interval will extend the displayed luminance beyond the
+maximum SDR luminance.
+
+It is guaranteed that SDR colors in this mode exactly match SDR colors in
+non-HDR content on the page. For example, a canvas pixel value of `'(1,0,0)'` in
+`'srgb'` is guaranteed to match the CSS color `'red'`.
+
+Performing appropriate tone mapping is the responsibility of the browser, the
+operating system, and the display device. If the `CanvasColorMetadata` specifies
+a maximum luminance that is greater than the display's luminance, then tone
+mapping will be applied to prevent clipping of luminance values below to the
+specified maximum luminance. Note that the tone mapping algorithm may not alter
+any SDR color values (otherwise the SDR color matching guarantee would be
+violated).
\ No newline at end of file
diff --git a/tone-mapping-scenarios.png b/tone-mapping-scenarios.png
index 243578e64d471cc1cbe5f6eb5a0b8638cbfd7283..8a36c7f5640417046071abfc056ff6f2ea072df8 100644
GIT binary patch
literal 9825
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

literal 16022
zcmdVBby!qw+dZs;f}|)Nf&)rO=MaK4N=k^dNRH$%q%=sEh!Qe@w19xLLrQ~mHwZ(=
zP|ASRZ;z;VJooQ;-uHXI<2&B(4-WS1WA7{WKF{k~Yn^L{sHw;k;!)$BJ9m!oo`Q_}
zxpNnk&z(DOhkF4yGfHY%2>d$_Q<s-ISI|wn0{p<XkW`jDcdjT3|H$|v@cXj8f)4E5
zIig0)-}zR%cc$mgiQm2_BdO_XxRGS{j$_0vWytH^_vX)WfwAS1kKXlG3UZRQ-NH+y
zUnee-O6vt*3Hl;)+15TZH2=iuuJ2;(U>Qqu1B(FZ>e|QWCm}aA;;2(6C}|TPNeMvN
zo*P^Z&b<_lFDKK>lz#|6o<I-vj~{j>lvs2NyDy4y5jR#%f3urT5Lm0QNP+d#ASd3G
zgWNaWXR5yOD-Q@}bwl!sMN#(mtlsR2z%+UvnytdKAV~;T%RF8um4VXkNzziS1d(ir
zu7xe$c&<{?0DnH8&_x?9;Knz@35kB?Y#K}a%4?m<l2z31TlF{<)9?3|)1z!_G}fCb
zjH;o?mU8>hI|uVI@acTLigGjMfmrKRxU+z>7MEd<_~E)?i0s6NeK-v$2$b~>GM=WK
zG_Y72XXGVpr&w6MbHBZvF-oj~WP!m?l}xsDez7Z2=DPRMwsKxRN&WR_%c*Sy>9Ps^
z(F`@XSE&waWs%Nl{Rjd-*?!a*rDQmaQRNC!X=@-3Bn`bqn;tg!#8ml8&?RP#r*E8<
zfC=!?JoRNrJ&&I8mPqrv)YMKAaF^IJFqYwZNJXeDb~;;EFC{Gq_cGpdY57ap_$o}W
z(aI2e${6sQ=SE0wapyE^u3ClXY<}|%`YSZdB?Eyx+bb%C*lTbBWl`X%lqN)YrYNT{
zQv2}ErrTJad*l1*@w*FM4o&YG=1fYn2`d|-LGptagG`Q^CUS?Jy~RhAH5tD!DDFdE
zj4L<V#5r?1Kn|Y_)zW=<3N(0q!uI?d!MFu7W>Im6fY`13aU<YY=a6Q>Y^6+gCYCqK
znC}Q}K5DyR6KskdNf6w~!^pjuwbA~CDz{9%tk@PL*VfiV74xL>m2GAyqyLD$W|`-;
zdxv=CWpA?RqH<v4N3rydvu~B6Lp^YU2_EO9#Vf2_2?VJ##j}ARFBql#X4N`AKzgal
z^ft>gJ>?#!sWZxbdUroA91hEq1fO;WlzH+1@e=!F6)sq}ee3y?S^My7(w9F}KZk}p
zylQJ^i#KO!%^GO$IbfN)Qr|kpznRaJ`+lC|+ECl0z<iKO*GpWv51}?jx>?YR6S~R+
zk*$Nm8}B$oDmcPjEynX;da47ZRuJ3s;}2-;6x@izk`B5{^Pc7_0dJBJ2$_dwwKac_
zN4?ic2WSof<tkfDtY$&11c3qaE9;fyz<^)lZ+_f%;(-bBL17!M#ZA4Ze~W0n*O*J4
z7PH>we;yQ89{4XLNT;_1CRZ>?^rqY#lNtl10*OHWyvfQR`_WAgCS8C$dT4f1oB3Z)
zwK2NFlkF6b-Jw&)VxnHeDLUv>PsX%^zUCQ@UgO9K`Zj3oT+(6P%sxE`bUsI8$yDnI
z>AjDx)Zzq<P&ug#x6pg7(M+*XM6ZR5Fk49{U5h3M&IXDwgE&^<?+Lxde;v%I%jgaY
z>(H#igG=ARiUkLSNgxlFOl{u5K>cam?c-`oG8wW-F=eUUAqruCZtB!a<?POrJEZ@7
z%WTijduKQGLjQX6uW>m2Yy;DK_z*&<W`V<+zJs?L(eZ?iecQ0p%ml^SRjK7gY3I3{
z$h+bf4nq}#31CLC35VP!PLZ><HT+0;6}$O-AF;%+EN8^c=`e(K=bcRDiqFI*saCZe
zbKIStI_9XxcQ71>RDa@<CU>5=2*f(<_z)3LaKIVX$c;8jKoF;Q*F+k5FYfy6CUSXf
zgcu!{VI!~1(iQj-oFKR)RGBvLL0i$x;wP_XPO(BuTXP}_qz+ZZzv+PXht~9e4s=D|
zo7n8HeHLP^eD6!yzXvBiYDh=dZft-p`+JU#8ZG+`TxKG`4;0Cum%Nv-BowfN3|EL`
z`oj%LA&p=eFvu&Ib|dG>3oI3`UTEU%w-O!-<)p+&1Xo9=C#6$CkYTm2Y|j<$NVntA
zT*<)v`fK6DZX43=ma5SvhWp?a)#`i^F2!mJ*jT)KZntvlWSrTec(}-jzs&YrGl^SX
zg-8azPH4sh#f(d;+~Od4c$$cdq~K!m_g%zF{9$qDWYB}9XD=$MP_?2GDkj*Z_}SP5
zxp=8*!5R_}<S|#*yU=84Cq?q|O*)eD@DRVNs)f4^xDy0iErxCjuPstMW0B?6A=O7a
z9TN=|brCZHZ};cIxNPw$AoJ4(5eAk6`8$mtm)AT<%uxe8XtS~S$sxoY2E}O3S2<pL
zv0O|yL@4^wMr&fUxVw6V;j6OMpv=gn1*y$uU`IhAmXdMkJznUf*~o0s16u>X>rOi}
z>qD$T)Ja6&T1x~C1O{!%m>L=l5S(I@AZQuuuB7EdW2R-Tgj$_!_RB4kqD;!0Gp2Rs
za-ETiS<Md<`mje9;R<@EYdCl%-%=0WFZ`9A?wb7Gb+>tv(66g1>@cTmnZad+{z#jj
zp@sag=27;i(T4?SSM1dgN^m)AfY%M*s*Xw%-+3j(ZP><=rmlHIGbDqOF?g}r&M7h$
zs>WV<rO=%8a!V^q3wXA)z9*5swS2*q2Br$ZJQwh~h*5sRp(7Brg120pY~6riF2B}(
zmndYH=G;aw?mxdZtkthYPB=ksSO_EIO1j;gwtvv$oeXNxCuOvwO(;rINUCD^(~Nh3
z5ovP0y6h(X`~&WFmE0$|SEKjbn<F}HoC;cI7r2ZJK=2Um_1zwcI;#D8f~!0oq#H6?
zPKN((M7b0fVn$dA1f+U;nGF#vwbcg)v>X~4f*bT>lti*jcy5h_lKpgLx2eJ&gh%#M
z2%Dyb!)Huy)Y`aQPd9N9a8AYKr$4m3gtN8NQ)IE0ohIf`Or*7?H7jsP-o0GGSqMa1
zVi4Qsx@PbJ+HF8yvNfIJehRBQRHvx69KT1b7d9D|U*SeJF<Ee}IW2fEL!mnN!=Nob
zO?umuOwHDc6Yub%O%zC|((_^yuDP+M)-8~0>WrSs0UAbJx0zjg@NEgXS<}6-+Ppcu
z=ZX}eb-oxF0V~k&?npq;n@@gc$BI?1Fke;l(^+?Q=&`6`ihrGQ+s7=(bZqOb&3H29
zcD~CygL|kl?HAVMd~RjLZ4kjbGs7+O;!)ku>G^h$`RQDn)%lcdL^?KN;Oos|8xfb6
zSS{6<i459#%+?;(6>2W!ovzVr9#+xsM{e$`WF6wq?A|$D-)7ET2rrExnh8S|y$`jS
z{U)d;U~Ph0c~uv*GnwDxaf+UfYxUZ6ven+K*OA#ALsu-o#uo?Ltg1|{;IPDQ1eg!q
z7=FjMCJMh<n2#NSobMkx0f*7uLov1C&MQ1!_oA$y*Aq3(?Z2MrRaVI4qTY6^Cpr=w
z{5@XPYhc&LMhR82qEAcCFKlOvvU1_6x0!V|;l!!;Sgp^#Lv-6G_xpMbsLajx(-z{@
z%Iop-nALYNO)Ck<Yu=9Mffaq#f!#z4>_H4~vtT1q5QT(<dA)r)+E!D=UZr$YW%O+n
zc<k)e`7Z9ex!)4PAI0vo_kCyR8PEE-QY0|GRPuOy5SJ=LZ&qgY-VLefNJ>V#OYTWP
z1c)p>0i&_P*BT*q_=#cCS(fKoWgIS=7csWi92S5s56gZjfC@o+Q7;Ax_g>Gd;Jt>R
zSi|@_cvU5fZ@n~ABbGI9Z>3|8ON+(!%n6lf0p3(%xAElTaHXvYQDy3OCOHmyYVKPV
zw2i6fSIo#c$;-4d?ubA1w@6jXSZEK<rkn!y7^d9aoYSvH@tGxcJBwl8PYw83HLUrn
zz2s0+0%K<1XDT{P>d+z<-&%^h-NZ{6bl^I%v?22dvn#`b(T?@Sfl$ksB{$aqB)0-J
zve)PM!bH_Rq<6u=@REbXC&8!_s~&L#lgplXMrHmRTltsnPRs+7pLY<ch-UpDLG+6D
z;e7|@0NqhUiIX=K4t*nYLy1pMS_Gasx%g@(;cee$C7SELrFM0vq65I}me8?}LY-QQ
zVqVv(F3mj_aHY+q^c^SNE)id)eh`p!0Po#N+YmkNOc{GtSn;l}c}%cz&0^w+tE0R`
zutj9@Sw)=Z*O1J%ljdl%gl`F`Dt`uTNQurMb2?$+))aF9L#%=Ye|$$dqY9t%0TY=O
z%$TcDf+HHs+I<=}>fGcXj(U$x`|{@Td`C2>9O9rpWEdO5_aw0-xwV`zk{e}^_`pG_
zR<kI1%|!o=mW{db`L`Z2Eb7fLnP>*O96CG4O--A)gu04wsEeB;64t>u!ukZFFKhx#
zBXVBJpA;g8rcQlY^geqaJl24mZ)b9|_Ido&ejKxe=lVLAM-SRDVhQvk1lKHpEhpy3
zmb1IlRVd*-ZlUL=6Z-znk*+WE=aK{H#oH2Ld|l2svpfYC!&5fAN<N_r?IWjRULvlp
zgkLh?Try(-;x5DWXpIdD{U~D^hpS>kI<TSOAmKJrdo18IRaNO<v{&4_SS@;304xdY
zQYzwJDC??+?VLRqNNo9|E2k1JN-)0gYH7z2ZK<cXGjXW9lGGS%-%q;|T(+4CnKX>1
z79)a~I2M99io_=L1H!|HhChrfPn+>j^d)9{A@Plljb>btcf1oqbPq*OztB5vSft)E
z3$+Ox>G_dYy;*t-OCaJSScP~AT4bq1diZ)PyMlPUhN-goVL`JFmqntN-kNv;?*+l?
z2A3345O@P$l4_eX3C06IG?r5jm&3aks@N28|2cAt(SuX;<>b8&FU{UfY8(y5rUne%
z;^l5GU_$Fwehu{*(p?CSek|V7$I!a01H85Y9}+edY>6F->E-^+k`6JE3YVfql6<oy
zm(eEStA&R5ieVq`^0(FACF#h<dV2X5uZL`WX~z@t`*!M02e<9K@L|nf^Q|-f`&vkZ
zC9_$qO(5*iR9x5x>*I+AS~=8)*%-b}rIvW|voG7KRoyyXv>Kfvg`jes#KPmXMr;%P
zh;p-Jzge<mK}d=&dz9SKFsBH*k$pvz{1GUloTJBB{<UcP%g0mcg6QJXgawd3uw>uA
z-KCos!Yn|_+59w+KB$FqyVSHQ*f6={$LgH~$#`%txnsF)kU51=FonoLSdN+w$o*Nm
z&1Y|A3ie%6+!te1J@@KPDrQ#ZV0|hg+lH?eaAXf61MoYnu<3h?LC`sk*F#Dsp#4Xl
zM@^~mxr14rq5EzE^%5fyG#_}-uK-v=-$Q)-Np$B^qyC87Xx95J1HFf+-8TsO7TKll
zhHe#ytRjk`Y2N9Ud9QmSLd~u_s^!yA?OcH$s933vLSKp8=(a?)`sC=*B@fPTAxcvx
zK~bd8efVoT-Q|X&XAi==7xZxbNCeq!xT(3P-0GZXtN<JhJV`Igfx=w{QP+UY@i~W-
zK49;qh!(Z8F6$wn;i#B)0}v8^FTy_p0NIal1~xD1J<Wr$X0eg4NEHcAY+6Y$_Y7KI
zr?2{eGT<&F2v}U0;%u=Df7@-~_h-P;>BI$+u+++i$*2`ST*?*Hke}_326gRlK4O-`
zl3N@Yo2#v`PFNE$%KFP)?p$i3k(pWw6ri97rfCtK-$a7?YCYT2d5Yt7FV&~PaHsY0
zC`>|8PuF=DHucIii}5im;Rn25^rV+d(z{Lp<ywuCS1a=%4oOvSDzdyG=MUC2-X4e(
zgp^a6ABwV<OvJm39B-yR|10w6i2BJIw3f0=P#wImAFcf>e6A3Sb>&(t=0Ojp^!&!u
zzfU@LR?;_0jd;X08~=jPv8`7(oAm))9jSvhd9?gy^EY)_o!ogeR}<gSGC9Dr=0$*S
zuxmgbWc>HOMa-w7jQ>g~I!r>)PdEW+*82XChuyKuMTa)<2P=p#5<v%wZkm2Hqgt9Y
zD<b+i)K}&J2oB$@+$BtKlxz|H^X1INq>sM;W{4&Q-V)59wYvb*;~ANeCW&@>`w!%=
zF{S5>1vbu9kp7iX{+Y@BJ03Y(m-3T~dK1h3Gxglx{mDW14`crW3H>J?iRt|a{gb|K
zZKekQGxhx6Pl2ThuqMCTzNT-{n>os2&$x(rvrtL^E%Tv`TUKcsJ>4OgSK8*}b2tr9
zhrdP`{Cx!C<akmy<$&i`Jet~cenYDbfA5T{|H%k3%D``0iIE3{=+3zHnMUyEUnvK_
zso`+rQti<Zj@N7-rz_!hLdq{*YD;+ZoiD}vYh#q>0{Zk^&RXsz*Ewx(!b%2q11`_S
z?BB^H$TBHPzh6&(9Fo$+>N&UHo-M9O8^lm1vAav0?x%Sps7d1+z{4Z<YwX<Jvz=u=
zI+oU}n#cwFnUAV%L`D2V%5c9UWzc4o+qDO$X^{$Fn0v0~IUf>rEd=DiZX<nqr4B=7
zW#5`rB4OCny#b&ub<^pm-q!n_s=v5##p4&WO!*m{vb2%=VBD*(8bzr_p6kxD8Gx_K
z4~=VAQsV?82N<GPBb~GANqGM?F~hP4QA$ZjS;DC_wi)BO^hfy(0n|7Ko%pnLA@lAJ
zLcd*dga7WXQ%uAK*%E;x<h;AsC1dEZ-7J6I?K!Ue5w;2c^fL-;I4rI?RMP!^ipqen
zVM8y+)7{<jfq6W#`ToA}OVIwXC$!*2G=lZi3pI;A9u%rO@i?lnsx_$DpBlezCq|9Y
zS<AUopxv)K+=Kx-u>M-xu>EAKSDJXL(&=`6E4?=yx0TeQ2-%(_nm84OeJ@3!Lb}*G
z*<+_&dEy#l?Kh&b+wDoDFG<_Yd16N5H$0!!=0~)9UQa?+x5vnOoF1cL9tR6?n~0_B
zC>BW+zh{VbVt3NK50713b7js<#eBSw;49WA<UtiYgG84*3u7`y3@zcQltFt`!V*jA
zxVVNBC-35S&}zw5-x4-Yrw?~VHw|_-R=bL4$h%F%7{8j$%*6IU*10w~$HwC=PWZb!
zkGV}$A8#V1pxp$DC@{jYOrraV{7ccxycdMc(T%vbX2x%5yxtrAn&){F5hEq&7U|d|
zIoRs4lbCF0W#W*cyfpXWZMz!`W>gh+*%rTo1}2QVs6i~g0ey5{bI2lvG{;O{0Xs!8
z!7zu88?&vv@o!rQ2uI2%@4ITd-)f_YdxgTtHwR^}kfw7p$GHFndt)(cQ!|mMov%vk
z$FArRYw7vI!bW5A>nQcct`4_Npf))AnR>8V24hQGV!fe-N%Fz@K$yg*kK*vX@(&2G
zY3L<;B_{31<N)4!z*{^`Zp-|L;zr^P!f`r>??bf!2utPdx?=`4*I8s$7?vp}SWRtX
zKltdspg#EWEtl4I>uCI>#ei@)O?dQWFZb+wj0sKe78I~r=3`C3{0udn4b5rgfKt`^
zbc>xdv{a00n>5`$E?`SHP=Dd(=DB4BboDA7$G~Z=+4V#Ay6)m<COS)EDLOCMyV(^Z
zWp*abZLZy;V7H<S5_C%r(gqXxXYddaj&gmd2}}8fimi8->-N@T6df!!rE@28SDcv;
z+Ah3Z`Rpk)Z}d8yEMX~U1oK@$lBga!4!XtT0TRRCXCHs}*nBqKaQws7N1dg!BnpRn
zhjn}a?}T~Tg=9XmpcU0wIdtSCdg$Mp8cOm`nM7hOy?{h(G@<7*hk#9}jkdbU`$m93
zj>)Gy3SBp%)rr+fS*aDpb$Bh9DC@~PzJ)jAsgC<3#8J*4VJ$kxZxW}fUL;7d$9ptz
zRrpi+(w!h1d9k+T?)#r^==7`B(y~5Dyv3}wVU_@9EEisL18%`ZPM1;LY@JsmTSJJq
zWa<o=lartOEdLy&B_>aLxj%Y*TMn%<<eYHe-a+XSCod#kA?A<-ifwt#2aI`Ep_^YJ
z+T5{_B$vG7nMjxAnAwey^C<U<&pjPLrXE33Y%ZI#7Vm9YT})=_S!^YHf5hI+KSB4r
z^&>gASNUPrg_*hrVQ1C*i}y45s2vgTINwQP?w51hg?UZQvsa@HK;W_mN)?Rl$MXh<
zdn1ERo2x`E;~i3oyQuXl=bMNUT;YR#M9GHk%_=c`nU8%ktIihWN8xwBQ!&%8Q{s46
zN3<VHITA58+=FE>4%Y@{LEUAaZh<o*`f5T;n|7>WWW2l&^%@N^(V~y@aTCA~6mDNq
zfK1hm&0qN6PcDE>(`5J<GKdxBJ^rR=2O0ll*o~~HYkab{XO@Z5q`919mz1DztMuOC
z;1f6gxeDh#K=HYkUHs|ljWQcIBGKH*d$HJS*UJ!bnO*D@v-ceewR9oFy2@fXsrIZ7
z`HsN+Ey3AlHCsvlmN3kVaGOu1wETqmO#%}Ae~0;;#x#P{P-53Ix|qY8E0d(i_8AXq
zN~cU+jG_YEzK~#tC>8JqqPeVjK|CG6%A6pV=}|eaXXy*WqEWzld|t%mhdAay2VS%|
zN$Z-#Y_P>Vh&%xQc>J;30)P$!nBRX(p!feNAOq!ruXRCJ|K~`+)aLh|hAA^NT6kf^
zJOG|xDhlGe7<KoDxZXa#^$RBa6{rHKVe1KKfygS9hctQr-}HSIQ`Qe(tA3X>^f4ue
zVPBvllY+V+&>33&m%4<+FML^N$9h)m_^(1!Oj8|RN$vn<*#JnM;7OsxuG_m@#vs1a
zE{fXWi%Wi1JIg`zho3i3B`H!AT)LGW)Y9HXZ!USQtuRY`@2GpEW^Gl7*PRj8*~Tos
zN9kA}QvG#^%j^4Mp=NZ4E0ebRywcv<59ouzBQzotsI6}I)P4s;PLwHSEX766W&l`u
zXbX@OI3M2g)A<~SwS02@z9TAV=9|h#B9S2KDesw@y059k&f6jOQy+b_=8w2Eb7jrv
zHIq!FPd{;qg&K(jtz(c6vLcaJJanH=;?&-c7IL@5(o{1DS7qF#`7T$Jzv12JacbX|
zDIc)Fh4en5LY-)#IdBM4TTF|JBfGLf^h%DP0Fk@{lSb~<9<`O%_cUI&?3=!N9O&1S
z7q2_Mxk~G)x~9Md@9fvQH+tw&SLsQ`^Y#%J3plz_y}p3bvc-yU+d}*}$L@IAZnygt
z$<_DgS^J{}Wwt`pn%b?%=|a?A@8cUitBe>?gIsa0!h)3{Eoeg@e1%_zj%#xH$$<OW
ziOMuHbpluA3P7y}Ni=Tv4PLk1gynWaP4#*V2}n0RCnm<$w#S04OqyAfq`A|uCB9#i
zNFV{<YT$XIMhHr~VRF?tG+YiVGUxswDb))>OhHBIzI^U-;>cS|xw(~QpC*VB&$S1N
z*v?fkQV~%`gx~`LS*_x?iqBH3oE~bD)T?Uwft#wL6K?x+vlFhqdP`?qVd8$j$^;Ld
z1FK$}pNd2$V<R%$a2kxc<kHleNhE4~4AIrwoO46TjG|xz+^jpY<*w8oTgMWK=T{WS
z=vYs_x=#}(@Ic{k;*Ahfk8#Jeey6AuS94XYtSm-*YPg#aHEi}uJC!;A_>~N<Zd6-%
zjAFF8Fg-(m(!nQICoO^Cwgv7C*x2NlobQG}eN#wNkb>gc-N68by%~ZFGILumGR&Ti
z4MU&CI*cyoEbyz($FugoeWRrn`Dr-C^%h%FM@T@;R1B~Dcm?6-Z1SraI&-wwj4P|3
zJ>({89gwrFk``*PZ!Kq&96LmFjG5jL2ljk-+sk(i@3Y9UjaET=q6tMJG-$^1`aY*p
z5D|jSpRc~m<@fJQW|ZVVmtFZ58$02Z(2Y=IJ2du+Y)84|L4t^6;6i-uUD|J<M)fs}
zBMeS~zL%yFh~etmuiv(1@?^k#bY-rOZ+z1iiNoE%iU#AV>OSO9>AK2XD6d%*#cYU`
zC0SOOOFIE(v^T{zH)Uy2qTO?ja=2@loGW>dqx_;J1g69^AbAmKFJ?1eF6zig;9{M3
zm6Y>w#pl!sXJjeRY_s)bpYZbZQt`@&C3H12=n}2oJ%u=aMJCw7qix4okDcj89|+K@
z>J`KN{s9~Roi%G??WI+M+aF!#sWUb%2q-q=sO03`SDWt#OD~OT>7-ky?<-JLv2huK
z^L4Lux?lP(PZqI~jOK%{e;Er?tng_OkOKDSkk*6AxD-|Qqb6Z<JnVQ9hi6U?A$LEt
zoTs**Cx8reRZS#~dtAev0xvM*SN8JQMI`Wd@fy&C4@AIYsj#yvnXg;e$+tm1q2e#-
zf3kfoUA2*BY~4jVcFbrpbaUd_3b|>VofY(HDY!a)FwUJ8(&*FKK%<Hs$Pn$}DGygL
zS8{>ByGX6JTRyY7;k-mCtJDD=0*mX+dr%5*8ooBq3Nxw)Pqn?KZe6_q@zIbb{P|9b
zjFxnHz6h|?8SlTIs0->3)t|#22%I9Xt3+l%1ubbq$Kobf$H$vG+I?s>Ov74pP))aA
zhHOD|Mb(;lo&-jH8OoctMPsvGP!UyG8t{ScTr|0*OtuXsW6!2bcycLK@LDFtdZhh0
z5YA-Pi-Rpw4bB8wGFYRq+v=jc+ty8*W=5!IS~hbFgFe3b649ltl8|14Hi`_HaTI^L
z=XA<DKU~w%4I(P~Wj*9wpo3V}xz=_^gAZ`$dA4$cx8@L}P3s<iWiDQ*KGC5Q%Ch~o
z3fcDBf;pw(NE(c!9J|#e?qZSl66du&^xhCoadSm<4Z|fjH>n|eHu2)B;B_-&5$!^7
zsyl+pC$?(y4zjAl@1sM~nxW@g;1t8=oeg)I@J&uo6}!@sO!xd}U|WgA`%_Upq6V`+
z6=3S?5j7Zb<HsT4pLZYl@?@U(5wk*4o5+4|&<Rh6?paO0wL-u~*146A6QVp|_#d4&
zKYa?$t*3|S+J`eLBs%Ofr!{D&I$u`MNP_n1zAEam)$&Q1Z<~YL*G-AZ<1i5tL^p#I
zFtE@b&qWExJbjr0KFlyBj)sMPTLylc1AdJdFiZTb@YiPkH_ZXRbeYrRpSFS{cb0#a
za{il=5>*}yV+BAxdV{G8u08%Khb{I0@D5Dq#F=2o^G^v5xR?OFk@*)z%#kxm@2^ta
ztOu|`-=(O={;8Qc0#aB-ufWW2tz{6=c(BZM3UaJh{N3Mocb31Zb`y=NbxTuF@%@t&
z&sjxPq{o~|)U3xE+AFb*xNa?}$K$&OHi>X3e;_}8^?cu@G(XM0<2doJ^{c_Bda4rl
zqEX>Gbn?Y#_Jr)!NlXFwhi$?AuGf`}xZ3Z{hnrPGx=uYbn^G^-Zjs`LfFhqg2#{9v
z0}mxdmY#psM-ap(d1M(91AQSkr}TVLt2O$kFCpg-RcG>gFB2)t=jT4DdTxy-cbV|6
zaLaIJD2h^Stf=t$k%%2>&StblKhYCN{waxmTY~)taT~tcoUaIM8fV*XYkSQ+KmVXs
zfkG=-f4XIB0<kPbX4BioUr=#}c6zH<uqCyP2k#kY!Mvf^;d+VQCaGviy`j6C$wUJ#
zpj{q&cKp_o_WY0LmDjG(yN5&7iuaf4q3<?1ZWOu<QEW3x!6W;G;WE6p<UzvfdUWzq
zg*JgWV{Vx@ofk8Ll7^5p6XbG~C63xA6i&9kU?<`jgSgU6!7TdlQ2EMWWOljDm8(iv
z)Qpgoc->H{=Z~GJdg9%;Ki@9g@@pnJ1w3ov*8<#4O|XRsRiEmmFw!aFTEX9x(jhod
z$z<u7cpZb3(8wkpAaNH-%a^!;QtY1}XTY^2E5<&ApaW-jHHBr%9rWbx7k^@hraGrJ
za&c&6PJ`{_M@j7ZDsK}o#HS~k74!g1#T?_zxGBgYUBgS-MTwUph%KBDe)o_$#p5Mz
z^WfsEzz9RYyde9BEQe}Xna1@6)t_}jeCO+x@4l7x;XWjiiY#-m@N0b{Zbi@bbZDmw
zUZemnfrm6lma1Rbkyi?%U1&`C1Jhy!o35EU)2^FNcHwr$KM`v95P|q}fOQ}{-F@{J
z4Dh5Cf*BOPN*QbkNx`mWC~$XuSk|AoB}dYc!EY%a=|sqFIM~Z^E0c%IKKvecmu1u=
zb*5xYbA4G=)K%~Ph!c(|zRioD>(@wE{Zb7Th@SbUXtT`YWVTmC%A`qCYPG4t+laMR
zf>Z86$AKZfT3GuW^FYwfE)(|Pqhq#$P3eo0TtO^AHP1b3673o9=7<7}9oFiURazix
zn02rWc#fHpX4fQM2jd5dj}DqaYs?&d-!<5pv&<HSaey8#%cF1$A5M}w27rk|rEF@w
zn54w)v?*n6m2JsuxZ&ZAMYRUj^3yhIu{Z0dvhhtGa&V9c=7Ne6f?=O3or*^QVICu|
z)kvUEmb}oJ`|gFX#9JrvuxTrO-^o{Qe|QDheb_JA^0<iA>k6`VKWU8-brGzhzx+}>
zTK_z|C{xF+DAn-&VbQ??pwO<Mez2~X;n|O4{TDqA-m~bTX+hDk_c<xcPQ1ExQQ6^B
zd_~6-xnJtoefQd}l+$Cq({Up+x%JlT9$&mqy5n*e*h>d^fGYb%YUUn1W8*Ec!R$0Z
znAj^`H~Tyz?Y1gZYd>>5^V2L~7kgZ8e;tX}8|Ue*C!TF1PE%d3Sl%LBu>ud{gGqFb
zUi&zr&(baILeCsmu-B@yuHe8dDaRnMZh}$QjB<;mv)DF@eiosvcYxYu3~|}S>VVDJ
zR0Na4V!Et;$ZJ!Pu`T*Ueg}j8s_wK8&uNvm7J|ywaYMeqSO;#GVPOR8PDKcDw~JS+
z3%3E)n-PIz73J3b2?7es$+F4&C|B{-<c`1k1>gt6RW)uy-<xj4W9y`SlT21(wS8tC
zv3I~8FW7h+u5gD{hNYjxWWMWhAzwE_aY>(G$;$`o3Er?VhC$m%3BSa*owxeJ{~v|6
zVUtKzrjEDQLpxtai9X_#<+%J^oy<ENpxS~-jUVeN6TVcqyy1U&FI+d0|FM#-aG*3+
ze+Roh`_nuHcaQg%dZbbnI$}svc`AV^s+2C_Om7P%<dvN6+a)hkt1=Jp>|=`TKkCt0
zr=A^Rdq7Y<v}0d`FY)2OY)&w1k5)+5yJY;oQh4KPJ^7mQT|=+1sOqHOX!04w;|YSo
z6r0^T_KEIs$~F77DZ{-!=2*}ng?y~putnu2k)M8Mm-&N~@Uxn;-y={`-(${+NO0Ha
zLX777u7DbX(^46t4;yYh#uFsOyp<(a?G<9b#&F4pj%Kyr({k6j)g5fp{p>n$OT$MO
z8@YC#1NG)-1yNAQ!?J{ci#|IfsS0F0B(i>v8P3&xH5z3G<|os<EmI495j`AH`q{ym
z(1q}!FHrDHK0@^jswu1Ixy{ANDtx-mI-T8s5GTg<$Qzk&XI{{K@=ac15{SYqldYdM
z^;=a+zzf18{($(z)lPNOjoA@Au?NXrQMVr*=)fW6qPS5|j>kvV=){Y)-T|=n<X4@q
z0Y}8LgD@8sg8ng6Gtx*qB&_i!s7l8EX?i?h=QwPy+S@41S(_fB3onZc5L}uXbJ@7>
zU_s)rvkkMDD7)|MMjmXR9x}Mm&Aw0N`;|{ce3Xai#1$|`1uWCbJ&##bkbmz<tc=_X
z9sB}Sph<TpgM=)MEwY)KzAq1~kwbHaxrMBXxvcRiP{YdhmTC`sx=-?01n7`<XBHK+
zF|)Mp1z&GqUHI_-50`-4eJAxJ9OBcB?^>iXoTqg4;b#k;@OxB;?4$A%8)G8IAIn{6
z_Yg+ybL#%P+J}5v`Zu-jY{ldGe<1nYoRIyxqc3<14QxhAj1l*D^yTEU#1E`L95}w{
z;OSo;HREBF_=>g35{=L0vArU3IyG}#c+xCk;}5t5g#NoO0msnp8l(a7yl)VqVE2Qv
z&TLhS8c@wa98E3>z$C)Mx|0HulIE36xN>XEFpBO=N88Zt`4sCKWPv8&1B+{Jejp+2
zK2hU+Y;t;(;#juJdu(XWqvMf(v~?e9vP-jt7-Z&kI;0m@Z<>WYtc9fFx30?ah{W05
zz?B>QP+D*K$#Lm;+_MmX3So!tEI5T*1{htE2-*MdZ37<}##7+Ovx=w3o}0(p^zK{d
z{R~PF@m^e`>Uv3vJX%Ex6rp8fUPgz)Zdr1>`=bF)n|?WFEc{%X&OCA^*iNXce|Gq;
zP7(~pg$f|EPloE4D7~E*D=DJsOLGT=K`c6XFs;O#bo&)RYj>k~e=Yqy<L-(zbVjed
z(<zB-0KD`kYj0QkLMM2$=I#bK_TdeKU|PB85JBFNHCnmDy_-=jZH7;&u*14<xWZWV
z!&xiyiaK7^*^Q~UbGH3UBd#RqG%q)7tq$}HN;X;AF!Cq-!O~>p5}uG4^F-tFx<=lr
z2t>oc>Gk`6t;J5l^}EB*3<bB}|KZ0KVvgfOo>>I&^8Ub2nBjgrBLWR49)CbvVFa8i
z?uP?GdvvA({=4d`!fDZR2G_|R{^4LqjOj>#p0T5Vp+9WBi}McV`ai4(`o@2P&3|h9
z(J$zUQEClbYJF#8%`g!q+n8Z65Bg<WKscfZU8WI9PQrh46_|WUb0I-^EcOeN=-{kQ
z!r#GKKm8JJg_u_-dANVs3%Wu?TnNr==6^r@=>S-iNfNzu<f(|Um;X3EGpGMg4u2X0
zess8xR>OGP6R$a;D9>!}e?Qz>`e7qDyZX$G@b{tq^926m+5OEQ-uNFK{`4sPcsg%?
z*zEs)_~pz=e|9yRL-yZ~`d{Y~gK>Z;BsqJoW2~p{X)^PpYJkUo|JPRlKWX~fYyj7t
z<NTRJn@=mb&IkF~DeE8#8KFK!qhpX}b!fBgeD%*~rbjGsRNw--9z4nAx$JK+#Ob0x
zT-fP&%@aeVoAW56Z5eUWe@vy~(hH$!-!#}a@t|vCjXgYF{Wp1~;S5ai=67dMnQUFW
z`?eIJL*iuuq}LXd!0H(~x{KKA&jGTF21w!i(3K7b0V30Rw&XK)VscJ$`bvoVv@6AD
zlA8>E@2=FhSJA1w?cz&0A&qV$D8pXqjs_W|@ieVvhNkwPQ%fpPoKs`WZd0Q_UNFi~
z5Q~6P!XGyaXSL}=0yPLRWc}s^umJlPV&vHq))T}fzJG;2+mT3C60&L*tRNGN#PE7>
zG}T)|gZoadISr|HPkj~8vX&EOE~al|4f~khEGS1x;>Ly#g|qg@8<H90b^GGVcnX`R
z@ok^IDm}rryYtu}GP3$vWfrd-g&{d}wOfPH3ZXZd-2(7#%BHUMN9b=xL!`yJ7?6XO
zjUqv+Sbo0OuwK11hFS{x{LoS+izT&tv0kwn9p50%6xx13_l86=g$49Dzq8bn@3Cok
zEb9d?P_MGQjSw#ppF`(JBL7>RIVvXJSa2&FFD?;vtisoqA<Gx|gJTdZL}x)(;d%v&
z^kTw6Q|oni<J~YCO9FYnyBs$5ATfSvsjHAfDLLs+pa>3J;w~TKD$f0>Hb`eQST>R@
zwQc`Jqzw;q=NGb&ToOQAq%x)aAsHd8&f`HBt<>70dMm%2L(13kpXF=8MYqN^Kljvy
z1c`H2R1!Ox|5CI0fBjpMe{vvg&HOSiVTwmTK7;wCbp87H<>=s-T!mS5#?oPR-@e9R
zLWiBDyiEI|ML$q$0m71?@{5e&_f-lB&t2`@HZ!r8w-L{roluz1Mu3k(#`fz@I+s#&
zBWb&jgpBreDd6}8?dkMh>$mGpaSS{_Q^I_*2O#Z+9Kfr%`HWc~CrLU2Rkt~9^t~6S
zYG3A~t^OxAhZ736A@%ju|68$WFH#isMco6{(c_|ZZT4wJ3R8ThNA&I4!A*{;|1Zih
z@UR+@*1!{ABUjQoN20OAwrljQc0y(zq}vu=C$reX{XXV>ZSROk;H8_PzJ|d#H9nv+
zfeR5;=b=xr<<jj8OF(u_(5tP5uDQIrDo%DT4C*#d0dKEDmgddm)c)HsS!@y8?JV^K
z7elmp%1UR3guf>bM;n3@GV`t`ggp>xtx}oZaNWH3qAbycfp+f+6Pp(8_5l7eMjith
zZU`6q4+K0O2Q=#JdYqZl5~>%Gntjo8m_&X-b*;7ipf_2eC0m)9%>cb0VzI~n_^HT+
z?D_<kbRG(#Xt=RlI-%tEx%J3SFoF~kyL%pVR<_XcZ=>8>rIj!Lw%&Yqd%B_~spfjh
zp*qcNl@(e)lAHU$hd%A$pLj?jN&KH)At9uS!PPM3r?ywp8qaR?DZSA^vTdR+qAqI$
z=Vyp_ea6E8rPk<_8NBK{h00JvBDJwp#HAm+W?z13xNMt5rX{nb@tT2X+tzgPGXsI5
zzsOBX`O%Hh<bG5<sD%6e(xYJLC`|F(j=B_&di}Jrd!%(Q1U}wo81ay(#@_N152I$B
zW+s*C9_{6{^WdS2HyPS8sxLnvaIa!k;L<H8{M<8mnU}rw>&3Zu+DCXOI>e<MJ_7#b
zZjUdoDs!>Tn6g*&1zpM?Ja$*+hJv<l^!JNgak}yHSjhieG<dSOREc9kM5Rleh~`ci
zTrQNBPnKG<B=<AP==W<qGMO;pq7N1B>Wd18KpALI%8y?WZURz@)9%4*nROj+vvFCL
zqeP89yvf3w)ab-X5<2!V9oAdZV>VFOH#ewAOb9N2`GOM?tFZXFXl|w9V7?~k`~Y};
zBblLkD>HlI(!$7CLqYct)kFKuHUWi+i%(-i&x%Un^ZZFzgP@&W+d@DNma(J{ZjyBE
zFMbNt#K3NM(n3AOwyC)Zb3L^dMq8+S85y}5rFqQffT6y^+S$=0{H$u@$FBkmHGznY
zG6)G_te8rrG5%<x2b8NE<yL5^TZWaQrzCh=#+9|ozx8vpan20S4O&87<#V{u;Qqk#
z2?0XMxCD}*gYS{x=+1Z)_yIou+eMqYnTd^Vp3wMMXfD*Fxb1-3VY-H`ONpY+4_X<0
zTOe}iV*k19Kx%Mi0h=UMJE|@vFX@%R>#7#P&?v{Eyq&p#f!vGr)fR8PHT&XGZW4{{
zM9DQD9q}#o8JYYv5?$dvo(Bh|t*UU7th+u`H?p-YUSGntqJ4W_zWasXRCU!<PM45x
zZ-j<d@mqYl-QoCq1MCB3nDP%KLDD|geGa<k{2YF1J(86dKYNvSf=82t@NrMR!bV$D
z35mvQPsEy5SxB4))}`_jnf~iInUZ`AMlY^Hss_UM+`QB9Krf6dL`^;3+C^X`sbcA7
z1=BMRIMq9hN9T<?`@YGHsGyq|Sk7f*F&RB}XUV7BqJA~Qee`)_Mj9f^3H5_C+J+fT
zLHofp{6x*`9UG)JK=H@)ZX|1QGg8xKj;vi~A3Q|&ZjO?tQGRPx%b~*EkMw*tUG^^I
z6ZpW7CnhV@6^<7>5UIrDua+3nkMArG-T>kkFH{Mrh*v3%&P-_2w~^1t?fFs8FI?7Y
z%-L^472hZS>Qc88sv&#y3_%q*QnsxBoTGkwO16MZJ{2~VN9@QYgf(B2?P=$~J!R&}
zuCTO9#*8`F>wvDY@NkK?YJRW`Zwuc)+uLKxiVgu_=#ccEzL|`T=sxbt!&H7;(NRZN
kfXWY3_4iiqozwGPA!DH9zyfOETk>=FWPu8j)MLN@19E>j&;S4c


From 33758e949edf9dbccf69c45f5065f69b1148f12d Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Fri, 3 Mar 2023 15:34:38 -0800
Subject: [PATCH 06/18] Address feedback comments

---
 color-space-conversions.png | Bin 5542 -> 4610 bytes
 hdr_html_canvas_element.md  | 153 ++++++++++++++++--------------------
 2 files changed, 68 insertions(+), 85 deletions(-)

diff --git a/color-space-conversions.png b/color-space-conversions.png
index bea0911a41e409dd75a1a54a2a9739a029e10b18..db3eea74f9fba5c23353c64fcfb8f19662ff3ba5 100644
GIT binary patch
literal 4610
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
J0wdRme*wE^)yV(=

literal 5542
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

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 9ab283c..e2286cd 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -94,7 +94,7 @@ Extend `PredefinedColorSpace` to include the following color spaces.
   partial enum PredefinedColorSpace {
     'rec2100-hlg',
     'rec2100-pq',
-    'linear-srgb'
+    'srgb-linear'
   }
 ```
 
@@ -122,9 +122,9 @@ The component signals are mapped to red, green and blue tristimulus values
 according to the Perceptual Quantizer (PQ) system system specified in Rec. ITU-R
 BT.2100.
 
-### linear-srgb
+### srgb-linear
 
-`linear-srgb` is specified in CSS Color 4 and is useful for physics-based
+`srgb-linear` is specified in CSS Color 4 and is useful for physics-based
 rendering of HDR scenes.
 
 ### Extend `CanvasRenderingContext2DSettings` to support higher bit depths
@@ -150,8 +150,9 @@ specifies the representation of each pixel of the _output bitmap_ of a
 
 ### Extend `ImageDataSettings` to support higher bit depths
 
-Add to `ImageDataSettings` a `ImageDataColorType` member that specifies the type
-of the `data` member of `ImageData`.
+Add to `ImageDataSettings` a `ImageDataColorType` member that specifies the
+conversion semantics and type of each of the items of the `data` member array of
+`ImageData`.
 
 ```idl
   partial dictionary ImageDataSettings {
@@ -161,43 +162,55 @@ of the `data` member of `ImageData`.
 
 ```idl
   enum ImageDataColorType {
-    "Uint8ClampedArray",
-    "Float16Array",
-    "Float32Array"
+    "unorm8",
+    "float16",
+    "float32"
     // and potentially others
   };
 ```
 
-## Add luminance and color gamut information to `ImageDataSettings` and `CanvasRenderingContext2DSettings`
+The values `"unorm8"`, `"float16"` and `"float32"` result in `data` returning an
+array with the type `Uint8ClampedArray`, `Float16Array`, `Float32Array`,
+respectively.
+
+## Add HDR rendering behavior and HDR metadata to `CanvasRenderingContext2DSettings`
 
 Add a new CanvasColorMetadata dictionary:
 
-  dictionary CanvasColorMetadata {
-    CanvasHighDynamicRangeMode mode = 'default';
-    CanvasSmpteSt2086Metadata smpteSt2086Metadata;
-  }
+```idl
+dictionary CanvasColorMetadata {
+  CanvasHighDynamicRangeMode mode = 'default';
+  CanvasSmpteSt2086Metadata smpteSt2086Metadata;
+}
+```
 
-  enum CanvasHighDynamicRangeMode {
-    // The default behavior.
-    // HDR is enabled for 'rec2100-hlg' and 'rec2100-pq' color spaces only.
-    'default',
-    // HDR is enabled for all color spaces
-    'extended',
-  }
+```idl
+enum CanvasHighDynamicRangeMode {
+  // The default behavior.
+  // HDR is enabled for 'rec2100-hlg' and 'rec2100-pq' color spaces only.
+  'default',
+  // HDR is enabled for all color spaces
+  'extended',
+}
+```
 
-  // SMPTE ST 2086 color volume metadata.
-  dictionary CanvasSmpteSt2086Metadata {
-    ColorVolume colorVolume;
-    required float minimumLuminanceNits;
-    required float maximumLuminanceNits;
-  }
+```idl
+// SMPTE ST 2086 color volume metadata.
+dictionary CanvasSmpteSt2086Metadata {
+  ColorVolume colorVolume;
+  required float minimumLuminanceNits;
+  required float maximumLuminanceNits;
+}
+```
 
 Add a mechanism for specifying this on `CanvasRenderingContext2D` and
 `OffscreenCanvasRenderingContext2D`.
 
+```idl
   partial interface CanvasRenderingContext2D/OffscreenCanvasRenderingContext2D {
     attribute CanvasColorMetadata colorMetadata;
   }
+```
 
 The semantics of `CanvasHighDynamicRangeMode` are as follows:
 
@@ -209,16 +222,17 @@ and the identity as its transfer function.
 converted to the *screen's native linear color space*, all of its color
 components are within the `[0, 1]` interval. When displaying content produced by
 a rendering context with `CanvasHighDynamicRangeMode` set to `'default'`, all
-colors that are within the *screen's default range* must not be gamut-mapped;
-other colors may be clipped or subject to screen-specific behavior.
+colors that are within the *screen's default range* must not be tone- or
+gamut-mapped; other colors may be clipped or subject to screen-specific
+behavior.
 
 * A color is said to be within a screen's *extended range* if, when that color
 is converted to the *screen's native linear color space*, all of its color
 components are within the `[0, highDynamicRangeHeadroom]` interval. When
 displaying content produced by a rendering context with
 `CanvasHighDynamicRangeMode` set to `'extended'`, all colors that are within the
-*screen's extended range* must not be gamut-mapped; other colors may be clipped
-or subject to screen-specific behavior.
+*screen's extended range* must not be tone- or gamut-mapped; other colors may be
+clipped or subject to screen-specific behavior.
 
 ## Annex A: Color space conversions
 
@@ -254,18 +268,33 @@ These conversions fall into two broad categories:
 ### Between HDR color spaces
 
 The conversion between `rec2100-pq` and `rec2100-hlg` is specified at [Report
-ITU-R BT.2408-5, Clause 6](https://www.itu.int/pub/R-REP-BT.2408),
+ITU-R BT.2408-5, Clause 6](https://www.itu.int/pub/R-REP-BT.2408)
+
+### From HDR to SDR color spaces
 
-### Between SDR and HDR color spaces
+#### `rec2100-pq` to `srgb`
 
-#### General
+Tone mapping from `rec2100-pq` to `srgb` is performed using the following steps:
 
-Conversions to and from `srgb` are provided for `rec2100-pq` and `rec2100-hlg` color spaces.
+* apply the Parametric Tone Mapping Method specified at [SMPTE ST 2094-10, Annex
+B](https://ieeexplore.ieee.org/document/7513370) using the following recommended
+parameter values:
+  * `TargetedSystemDisplayMaximumLuminance` = 100
+  * `TargetedSystemDisplayMinimumLuminance` = 0.1
+* convert to sRGB using `rec2100DisplaytoSRGB()` below
 
-#### `rec2100-pq` to `srgb`
+```javascript
+function rec2100DisplaytoSRGB(r, g, b) {
+  const [rt, gt, bt] = matrixXYZtoRec709(matrixBT2020toXYZ(r, g, b));
+  const rp = Math.pow(rt / 100, 1/2.4);
+  const gp = Math.pow(gt / 100, 1/2.4);
+  const bp = Math.pow(bt / 100, 1/2.4);
+  return [rp, gp, bp];
+}
+```
 
-Tone mapping from `rec2100-pq` to `srgb` is specified at [SMPTE ST 2094-10,
-Annex B](https://ieeexplore.ieee.org/document/7513370).
+A demonstration of the method is provided at
+<https://www.sandflow.com/public/tone-mapping/index.html>.
 
 #### `rec2100-hlg` to `srgb`
 
@@ -318,6 +347,8 @@ function tonemapREC2100HLGtoSRGBdisplay(r, g, b) {
 }
 ```
 
+### From SDR to HDR color spaces
+
 #### `srgb` to `rec2100-hlg`
 
 See [TTML 2, Annex Q.2, steps 1-8](https://www.w3.org/TR/ttml2/#hlg-hdr) with
@@ -326,51 +357,3 @@ See [TTML 2, Annex Q.2, steps 1-8](https://www.w3.org/TR/ttml2/#hlg-hdr) with
 #### `srgb` to `rec2100-pq`
 
 See [TTML 2, Annex Q.1, steps 1-8](https://www.w3.org/TR/ttml2/#hdr-compositing).
-
-## Annex B: Compositing the HDR `HTMLCanvasElement`
-
-The compositing behavior of an `HTMLCanvasElement` may be specified via the
-`CanvasColorMetadata` attribute of its rendering context.
-
-### Default behavior
-
-This section describes the default compositing behavior for canvas element. This
-is the behavior that happens if the `CanvasColorMetadata` is not set, or if is
-called specifying `'default'` as the mode.
-
-In this mode, the `HTMLCanvasElement` will be composited exactly as an `<img>`
-or `<video>` element with a source in the canvas' color space would be
-composited.
-
-This means that if the canvas' color space is `'rec2100-hlg'` or `'rec2100-pq'`,
-then the canvas will be composited using high dynamic range, where available.
-
-Otherwise, e.g. if the canvas' color space is `'srgb-linear'` or `'srgb'`, the
-canvas will not be composited using high dynamic range. Pixel values outside of
-the [0, 1] interval will extend the displayed gamut beyond sRGB, but not the
-displayed luminance beyond the maximum SDR luminance.
-
-Performing appropriate tone mapping is the responsibility of the browser, the
-operating system, and the display device. If the `CanvasColorMetadata` is set to
-specify metadata and the canvas' color space is `'rec2100-pq'`, then this
-metadata will be interpreted during compositing in the same way that it would be
-interpreted if included in a source displayed via an `<img>` or `<video>`
-element.
-
-### Extended mode
-
-If the canvas' color space is `'srgb-linear'` or `'srgb'`, then pixels values
-outside of the [0, 1] interval will extend the displayed luminance beyond the
-maximum SDR luminance.
-
-It is guaranteed that SDR colors in this mode exactly match SDR colors in
-non-HDR content on the page. For example, a canvas pixel value of `'(1,0,0)'` in
-`'srgb'` is guaranteed to match the CSS color `'red'`.
-
-Performing appropriate tone mapping is the responsibility of the browser, the
-operating system, and the display device. If the `CanvasColorMetadata` specifies
-a maximum luminance that is greater than the display's luminance, then tone
-mapping will be applied to prevent clipping of luminance values below to the
-specified maximum luminance. Note that the tone mapping algorithm may not alter
-any SDR color values (otherwise the SDR color matching guarantee would be
-violated).
\ No newline at end of file

From c663547c60d58c128e4b19bfad19653d59f5b7a9 Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Mon, 13 Mar 2023 15:49:50 -0700
Subject: [PATCH 07/18] Fix typos

---
 hdr_html_canvas_element.md | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index e2286cd..aa71668 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -15,11 +15,12 @@ widespread use today:
 results in contouring and banding, even for traditional standard dynamic range
 (SDR) imagery, like sRGB, which covers a typical luminance range between 0 and
 100 cd/m<sup>2</sup>. These quantization artifacts become unacceptable with
-High-Dynamic Range (HDR) imagery, supports luminance ranges between 0 and up to
-10,000 cd/m<sup>2</sup>.
+High-Dynamic Range (HDR) imagery, which supports luminance ranges between 0 and
+up to 10,000 cd/m<sup>2</sup>.
 
 * As specified at [Rec. ITU-R BT.2100](https://www.itu.int/rec/R-REC-BT.2100),
-two color spaces tailored for HDR imagery have developed: BT.2100 PQ and BT.2100
+two color spaces tailored for HDR imagery have been developed: BT.2100 PQ and
+BT.2100
 HLG.
 
 * To render HDR imagery, it is useful to have information on the luminance range
@@ -238,14 +239,14 @@ clipped or subject to screen-specific behavior.
 
 ### Background
 
-In general, application should avoid conversions between color spaces and
+In general, applications should avoid conversions between color spaces and
 maintain imagery in its original color space: conversions between color spaces
 are not necessarily reversible and do not necessarily result in the same image
-appearance. In particular, conversion of an HDR image to an SDR will result in a
-signification loss of information and an SDR image that is different from the
+appearance. In particular, conversion of an HDR image to SDR will result in a
+significant loss of information and an SDR image that is different from the
 SDR image that would have been mastered from the same source material. From that
 perspective, converting from HDR to SDR imagery is similar to converting RGBA
-images to 16-color pallette images.
+images to 16-color palette images.
 
 Nevertheless, the HTML specification allows color space conversion in several
 scenarios, e.g., when [drawing images to a

From 39812621c12e8d585a37bcb5a3538b17d96db7c7 Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Mon, 13 Mar 2023 16:27:02 -0700
Subject: [PATCH 08/18] Further simplify the proposal

---
 hdr_html_canvas_element.md | 137 ++++++++++++-------------------------
 1 file changed, 45 insertions(+), 92 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index aa71668..1cb819e 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -1,4 +1,4 @@
-# Adding support High Dynamic Range (HDR) imagery to HTML Canvas
+# Adding support High Dynamic Range (HDR) imagery to HTML Canvas: a baseline proposal
 
 ## Introduction
 
@@ -20,72 +20,41 @@ up to 10,000 cd/m<sup>2</sup>.
 
 * As specified at [Rec. ITU-R BT.2100](https://www.itu.int/rec/R-REC-BT.2100),
 two color spaces tailored for HDR imagery have been developed: BT.2100 PQ and
-BT.2100
-HLG.
+BT.2100 HLG. All movies and TVs are distributed using either of these two color
+spaces. Display interfaces, such as HDMI, also use these color spaces.
 
 * To render HDR imagery, it is useful to have information on the luminance range
-and color gamut that (a) are supported by the display and (b) were used when
-authoring the image.
+and color gamut that were used when authoring the image.
 
 Accordingly, the following API modifications are needed to manipulate HDR images
 in HTML Canvas:
 
-1. add the ability to query the luminance range and color gamut of the display
-2. add BT.2100 PQ and BT.2100 HLG color spaces to `PredefinedColorSpace`
-3. add higher bit depth capabilities to `CanvasRenderingContext2DSettings`
-4. add higher bit depth capabilities to `ImageDataSettings`
-5. add luminance and color gamut information to `ImageDataSettings` and
+1. add BT.2100 PQ and BT.2100 HLG color spaces to `PredefinedColorSpace`
+2. add higher bit depth capabilities to `CanvasRenderingContext2DSettings`
+3. add higher bit depth capabilities to `ImageDataSettings`
+4. add luminance and color gamut information to `ImageDataSettings` and
    `CanvasRenderingContext2DSettings`
 
-## Scope
-
-We propose to extend the Web Platform to allow the HTML Canvas API to manipulate
-High Dynamic Range (HDR) images.
+## Target use cases
 
-## Add the ability to query the luminance range and color gamut of the display
+The primary use case is the drawing of HDR images into an HTML Canvas element
+such that the images are displayed as they would have been if they had been
+introduced in an `img` or `video` elements. Example applications include:
 
-### Querying screen HDR parameters
+* drawing images retrieved from a file whose format is not supported by the
+  `img` or `video` elements
+* collages of images, both HDR and SDR, for a variety of sources
+* drawing of UI elements that accompany an HDR video presentation
 
-Add a new attribute to `ScreenAdvanced` to indicate the HDR headroom currently
-available on the screen.
-
-```idl
-  partial interface ScreenAdvanced {
-    // The maximum luminance that the screen is capable of displaying across
-    // the full area of the screen, as a multiple of the luminance of SDR white.
-    // This will have a value of 1.0 for screens that are not HDR capable.
-    readonly attribute double highDynamicRangeHeadroom;
-  }
-```
+## Scope
 
-### Querying screen wide color gamut parameters
+We propose a minimal extension to the Web Platform to allow the HTML Canvas API
+to manipulate High Dynamic Range (HDR) images expressed using the widespread
+BT.2100 PQ and BT.2100 HLG color spaces.
 
-Add new attributes to `ScreenDetailed` to indicate the gamut and white point of
-the screen.
+This proposal does not preclude future additional extensions.
 
-```idl
-  partial interface ScreenDetailed {
-    // The color volume that the screen is capable of displaying.
-    readonly attribute ColorVolume colorVolume;
-  }
-```
-
-```idl
-  dictionary ColorVolume {
-    // The color primaries and white point of a color volume, in CIE 1931 xy
-    // coordinates.
-    required double redPrimaryX;
-    required double redPrimaryY;
-    required double greenPrimaryX;
-    required double greenPrimaryY;
-    required double bluePrimaryX;
-    required double bluePrimaryY;
-    required double whitePointX;
-    required double whitePointY;
-  }
-```
-
-## Add color spaces intended for use with HDR imagery
+## Add color spaces intended for use with HDR images
 
 ### General
 
@@ -95,10 +64,15 @@ Extend `PredefinedColorSpace` to include the following color spaces.
   partial enum PredefinedColorSpace {
     'rec2100-hlg',
     'rec2100-pq',
-    'srgb-linear'
   }
 ```
 
+Extending `PredefinedColorSpace` automatically extends
+`CanvasRenderingContext2DSettings` and `ImageDataSettings`.
+
+A Canvas that is initialized with `rec2100-pq` and `rec2100-hlg` is an HDR
+Canvas; otherwise it is an SDR Canvas.
+
 As illustrated below, the tone mapping of `rec2100-pq` and `rec2100-hlg` images,
 i.e. the rendering of an image with a given dynamic range onto a display with
 different dynamic range, is performed by the platform. This is akin to the
@@ -106,12 +80,13 @@ scenario where the `src` of an `img` element is a PQ or HLG image.
 
 ![Tone mapping scenarios](./tone-mapping-scenarios.png)
 
+SDR images that are drawn to an HDR Canvas are first converted to an HDR
+representation. Conversely, HDR images that are drawn into SDR Canvas are first
+converted to an SDR representation.
+
 Conversions to and from `rec2100-pq` and `rec2100-hlg` are detailed in Annex A
 below.
 
-Extending `PredefinedColorSpace` automatically extends
-`CanvasRenderingContext2DSettings` and `ImageDataSettings`.
-
 ### rec2100-hlg
 
 The component signals are mapped to red, green and blue tristimulus values
@@ -123,11 +98,6 @@ The component signals are mapped to red, green and blue tristimulus values
 according to the Perceptual Quantizer (PQ) system system specified in Rec. ITU-R
 BT.2100.
 
-### srgb-linear
-
-`srgb-linear` is specified in CSS Color 4 and is useful for physics-based
-rendering of HDR scenes.
-
 ### Extend `CanvasRenderingContext2DSettings` to support higher bit depths
 
 Add to `CanvasRenderingContext2DSettings` a `CanvasColorType` member that
@@ -180,19 +150,23 @@ Add a new CanvasColorMetadata dictionary:
 
 ```idl
 dictionary CanvasColorMetadata {
-  CanvasHighDynamicRangeMode mode = 'default';
   CanvasSmpteSt2086Metadata smpteSt2086Metadata;
 }
 ```
 
 ```idl
-enum CanvasHighDynamicRangeMode {
-  // The default behavior.
-  // HDR is enabled for 'rec2100-hlg' and 'rec2100-pq' color spaces only.
-  'default',
-  // HDR is enabled for all color spaces
-  'extended',
-}
+  dictionary ColorVolume {
+    // The color primaries and white point of a color volume, in CIE 1931 xy
+    // coordinates.
+    required double redPrimaryX;
+    required double redPrimaryY;
+    required double greenPrimaryX;
+    required double greenPrimaryY;
+    required double bluePrimaryX;
+    required double bluePrimaryY;
+    required double whitePointX;
+    required double whitePointY;
+  }
 ```
 
 ```idl
@@ -213,28 +187,6 @@ Add a mechanism for specifying this on `CanvasRenderingContext2D` and
   }
 ```
 
-The semantics of `CanvasHighDynamicRangeMode` are as follows:
-
-* Define a *screen's native linear color space* to be the color space with color
-primaries and white point set to the screen's `ScreenDetailed`'s `colorVolume`
-and the identity as its transfer function.
-
-* A color is said to be within a *screen's default range* if, when that color is
-converted to the *screen's native linear color space*, all of its color
-components are within the `[0, 1]` interval. When displaying content produced by
-a rendering context with `CanvasHighDynamicRangeMode` set to `'default'`, all
-colors that are within the *screen's default range* must not be tone- or
-gamut-mapped; other colors may be clipped or subject to screen-specific
-behavior.
-
-* A color is said to be within a screen's *extended range* if, when that color
-is converted to the *screen's native linear color space*, all of its color
-components are within the `[0, highDynamicRangeHeadroom]` interval. When
-displaying content produced by a rendering context with
-`CanvasHighDynamicRangeMode` set to `'extended'`, all colors that are within the
-*screen's extended range* must not be tone- or gamut-mapped; other colors may be
-clipped or subject to screen-specific behavior.
-
 ## Annex A: Color space conversions
 
 ### Background
@@ -306,6 +258,7 @@ _Output:_ Full-range non-linear floating-point `srgb` pixel with black at 0.0
 and diffuse white at 1.0. Values may exist outside the range 0.0 to 1.0.
 
 _Process:_
+
   1. Pseudo-linearize the HLG signal exploiting its backwards compatibility with
      SDR consumer displays
   2. Convert from ITU BT.2100 color space to sRGB color space

From c6ba457330bc34aecd8f89bf179f5115531ac80a Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Sun, 19 Mar 2023 13:01:09 -0700
Subject: [PATCH 09/18] Address comments

---
 hdr_html_canvas_element.md | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 1cb819e..f76237c 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -39,12 +39,14 @@ in HTML Canvas:
 
 The primary use case is the drawing of HDR images into an HTML Canvas element
 such that the images are displayed as they would have been if they had been
-introduced in an `img` or `video` elements. Example applications include:
+introduced in an `img` or `video` element. Example applications include:
 
 * drawing images retrieved from a file whose format is not supported by the
   `img` or `video` elements
-* collages of images, both HDR and SDR, for a variety of sources
-* drawing of UI elements that accompany an HDR video presentation
+* collage of images, both HDR and SDR
+* drawing of visual elements that are related to an HDR video presentation, with
+  the expectation that the visual elements match the look of the video
+  presentation.
 
 ## Scope
 
@@ -58,7 +60,8 @@ This proposal does not preclude future additional extensions.
 
 ### General
 
-Extend `PredefinedColorSpace` to include the following color spaces.
+Extend [`PredefinedColorSpace`](https://html.spec.whatwg.org/multipage/canvas.html#predefinedcolorspace) to
+include the following color spaces.
 
 ```idl
   partial enum PredefinedColorSpace {
@@ -101,7 +104,8 @@ BT.2100.
 ### Extend `CanvasRenderingContext2DSettings` to support higher bit depths
 
 Add to `CanvasRenderingContext2DSettings` a `CanvasColorType` member that
-specifies the representation of each pixel of the _output bitmap_ of a
+specifies the representation of each pixel of the [output
+bitmap](https://html.spec.whatwg.org/multipage/canvas.html#output-bitmap) of a
 `CanvasRenderingContext2D` and `OffscreenCanvasRenderingContext2D`.
 
 ```idl
@@ -305,9 +309,9 @@ function tonemapREC2100HLGtoSRGBdisplay(r, g, b) {
 
 #### `srgb` to `rec2100-hlg`
 
-See [TTML 2, Annex Q.2, steps 1-8](https://www.w3.org/TR/ttml2/#hlg-hdr) with
-`tts:luminanceGain = 203/80`.
+See [TTML 2, Annex Q.2, steps 1-8](https://www.w3.org/TR/ttml2/#hlg-hdr).
 
 #### `srgb` to `rec2100-pq`
 
-See [TTML 2, Annex Q.1, steps 1-8](https://www.w3.org/TR/ttml2/#hdr-compositing).
+See [TTML 2, Annex Q.1, steps 1-8](https://www.w3.org/TR/ttml2/#hdr-compositing) with
+`tts:luminanceGain = 203/80`.

From 9d02917c5345e5b722e30566237ce677acdf43cc Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Sun, 19 Mar 2023 14:22:48 -0700
Subject: [PATCH 10/18] Clarify the scope of the proposal

---
 hdr_html_canvas_element.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index f76237c..1c7fc57 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -54,7 +54,12 @@ We propose a minimal extension to the Web Platform to allow the HTML Canvas API
 to manipulate High Dynamic Range (HDR) images expressed using the widespread
 BT.2100 PQ and BT.2100 HLG color spaces.
 
-This proposal does not preclude future additional extensions.
+This proposal:
+
+* does not target applications that require high-performance custom image
+  tone-mapping or compositing methods.
+* is not intended to limit the feature of HTML Canvas, such as support for
+  additional color spaces like a linear high-dynamic range color space.
 
 ## Add color spaces intended for use with HDR images
 

From 5b16baf64685519b3dccb5576a249b32a0fe1045 Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Sun, 19 Mar 2023 17:13:05 -0700
Subject: [PATCH 11/18] Address feedback from Mike Smith

---
 hdr_html_canvas_element.md | 54 ++++++++++++++++++++++++--------------
 1 file changed, 34 insertions(+), 20 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 1c7fc57..0ca3936 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -20,8 +20,9 @@ up to 10,000 cd/m<sup>2</sup>.
 
 * As specified at [Rec. ITU-R BT.2100](https://www.itu.int/rec/R-REC-BT.2100),
 two color spaces tailored for HDR imagery have been developed: BT.2100 PQ and
-BT.2100 HLG. All movies and TVs are distributed using either of these two color
-spaces. Display interfaces, such as HDMI, also use these color spaces.
+BT.2100 HLG. All movies and TV shows are distributed using either of these two
+color spaces. Products with HDMI and/or DisplayPort interfaces, also use these
+color spaces for HDR support.
 
 * To render HDR imagery, it is useful to have information on the luminance range
 and color gamut that were used when authoring the image.
@@ -45,7 +46,7 @@ introduced in an `img` or `video` element. Example applications include:
   `img` or `video` elements
 * collage of images, both HDR and SDR
 * drawing of visual elements that are related to an HDR video presentation, with
-  the expectation that the visual elements match the look of the video
+  the expectation that the visual elements match the look of the HDR video
   presentation.
 
 ## Scope
@@ -58,8 +59,9 @@ This proposal:
 
 * does not target applications that require high-performance custom image
   tone-mapping or compositing methods.
-* is not intended to limit the feature of HTML Canvas, such as support for
-  additional color spaces like a linear high-dynamic range color space.
+* does not preclude adding other HDR capabilities to HTML Canvas, such as
+  support for additional color spaces like a linear high-dynamic range color
+  space.
 
 ## Add color spaces intended for use with HDR images
 
@@ -97,20 +99,23 @@ below.
 
 ### rec2100-hlg
 
-The component signals are mapped to red, green and blue tristimulus values
-according to the Hybrid Log-Gamma (HLG) system specified in Rec. ITU-R BT.2100.
+The non-linear component signals {R', G', B'} are mapped to red, green and blue
+tristimulus values according to the Hybrid Log-Gamma (HLG) system specified in
+Rec. ITU-R BT.2100.
 
 ### rec2100-pq
 
-The component signals are mapped to red, green and blue tristimulus values
-according to the Perceptual Quantizer (PQ) system system specified in Rec. ITU-R
-BT.2100.
+The non-linear component signals {R', G', B'} are mapped to red, green and blue
+tristimulus values according to the Perceptual Quantizer (PQ) system system
+specified in Rec. ITU-R BT.2100.
 
-### Extend `CanvasRenderingContext2DSettings` to support higher bit depths
+_NOTE: {R', G', B'} are in the range [0, 1], i.e. they are not expressed in
+cd/m<sup>2</sup>_
+
+## Extend `CanvasRenderingContext2DSettings` to support higher bit depths
 
 Add to `CanvasRenderingContext2DSettings` a `CanvasColorType` member that
-specifies the representation of each pixel of the [output
-bitmap](https://html.spec.whatwg.org/multipage/canvas.html#output-bitmap) of a
+specifies the representation of each pixel of the [output bitmap](https://html.spec.whatwg.org/multipage/canvas.html#output-bitmap) of a
 `CanvasRenderingContext2D` and `OffscreenCanvasRenderingContext2D`.
 
 ```idl
@@ -126,9 +131,18 @@ bitmap](https://html.spec.whatwg.org/multipage/canvas.html#output-bitmap) of a
   };
 ```
 
-`colorType = "unorm8"` corresponds to HTML Canvas as it exists today.
+When `colorType = "unorm8"`, the non-linear component signals {R', G', B'} are
+quantized using full range quantization, i.e. they are multiplied by 255 and
+rounded to the nearest integer. For example, R' = 0.5 is represented by the
+integer value 128.
+
+When `colorType = "float16"`, the non-linear component signals {R', G', B'} are
+not quantized, i.e. R' = 0.5 is represented by the floating point value 0.5.
+
+_NOTE: `colorType = "unorm8"` corresponds to HTML Canvas as it exists today ans
+should not be used to represent HDR signal, as detailed in the introduction._
 
-### Extend `ImageDataSettings` to support higher bit depths
+## Extend `ImageDataSettings` to support higher bit depths
 
 Add to `ImageDataSettings` a `ImageDataColorType` member that specifies the
 conversion semantics and type of each of the items of the `data` member array of
@@ -239,14 +253,14 @@ ITU-R BT.2408-5, Clause 6](https://www.itu.int/pub/R-REP-BT.2408)
 Tone mapping from `rec2100-pq` to `srgb` is performed using the following steps:
 
 * apply the Parametric Tone Mapping Method specified at [SMPTE ST 2094-10, Annex
-B](https://ieeexplore.ieee.org/document/7513370) using the following recommended
+B](https://ieeexplore.ieee.org/document/9405553) using the following recommended
 parameter values:
   * `TargetedSystemDisplayMaximumLuminance` = 100
   * `TargetedSystemDisplayMinimumLuminance` = 0.1
-* convert to sRGB using `rec2100DisplaytoSRGB()` below
+* convert to sRGB using `rec2020SDRLineartoSRGB()` below
 
 ```javascript
-function rec2100DisplaytoSRGB(r, g, b) {
+function rec2020SDRLineartoSRGB(r, g, b) {
   const [rt, gt, bt] = matrixXYZtoRec709(matrixBT2020toXYZ(r, g, b));
   const rp = Math.pow(rt / 100, 1/2.4);
   const gp = Math.pow(gt / 100, 1/2.4);
@@ -318,5 +332,5 @@ See [TTML 2, Annex Q.2, steps 1-8](https://www.w3.org/TR/ttml2/#hlg-hdr).
 
 #### `srgb` to `rec2100-pq`
 
-See [TTML 2, Annex Q.1, steps 1-8](https://www.w3.org/TR/ttml2/#hdr-compositing) with
-`tts:luminanceGain = 203/80`.
+See [TTML 2, Annex Q.1, steps 1-8](https://www.w3.org/TR/ttml2/#hdr-compositing)
+with `tts:luminanceGain = 203/80`.

From c0b6e55c877bd57ced48b164ae9a29dbcf31d04f Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Mon, 20 Mar 2023 08:05:10 -0700
Subject: [PATCH 12/18] Fix typo

---
 hdr_html_canvas_element.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 0ca3936..0c71cb0 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -21,7 +21,7 @@ up to 10,000 cd/m<sup>2</sup>.
 * As specified at [Rec. ITU-R BT.2100](https://www.itu.int/rec/R-REC-BT.2100),
 two color spaces tailored for HDR imagery have been developed: BT.2100 PQ and
 BT.2100 HLG. All movies and TV shows are distributed using either of these two
-color spaces. Products with HDMI and/or DisplayPort interfaces, also use these
+color spaces. Products with HDMI and/or DisplayPort interfaces also use these
 color spaces for HDR support.
 
 * To render HDR imagery, it is useful to have information on the luminance range
@@ -139,7 +139,7 @@ integer value 128.
 When `colorType = "float16"`, the non-linear component signals {R', G', B'} are
 not quantized, i.e. R' = 0.5 is represented by the floating point value 0.5.
 
-_NOTE: `colorType = "unorm8"` corresponds to HTML Canvas as it exists today ans
+_NOTE: `colorType = "unorm8"` corresponds to HTML Canvas as it exists today and
 should not be used to represent HDR signal, as detailed in the introduction._
 
 ## Extend `ImageDataSettings` to support higher bit depths

From eb3581a7c0d2eac1bab12802d8e4531ba61dedcb Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Tue, 18 Apr 2023 22:36:59 -0700
Subject: [PATCH 13/18] Change CanvasColorType to CanvasDataType

---
 hdr_html_canvas_element.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 0c71cb0..eaaa019 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -114,48 +114,48 @@ cd/m<sup>2</sup>_
 
 ## Extend `CanvasRenderingContext2DSettings` to support higher bit depths
 
-Add to `CanvasRenderingContext2DSettings` a `CanvasColorType` member that
+Add to `CanvasRenderingContext2DSettings` a `CanvasDataType` member that
 specifies the representation of each pixel of the [output bitmap](https://html.spec.whatwg.org/multipage/canvas.html#output-bitmap) of a
 `CanvasRenderingContext2D` and `OffscreenCanvasRenderingContext2D`.
 
 ```idl
   partial dictionary CanvasRenderingContext2DSettings {
-    CanvasColorType colorType = "unorm8";
+    CanvasDataType dataType = "unorm8";
   };
 ```
 
 ```idl
-  enum CanvasColorType {
+  enum CanvasDataType {
     "unorm8",
     "float16",
   };
 ```
 
-When `colorType = "unorm8"`, the non-linear component signals {R', G', B'} are
+When `dataType = "unorm8"`, the non-linear component signals {R', G', B'} are
 quantized using full range quantization, i.e. they are multiplied by 255 and
 rounded to the nearest integer. For example, R' = 0.5 is represented by the
 integer value 128.
 
-When `colorType = "float16"`, the non-linear component signals {R', G', B'} are
+When `dataType = "float16"`, the non-linear component signals {R', G', B'} are
 not quantized, i.e. R' = 0.5 is represented by the floating point value 0.5.
 
-_NOTE: `colorType = "unorm8"` corresponds to HTML Canvas as it exists today and
+_NOTE: `dataType = "unorm8"` corresponds to HTML Canvas as it exists today and
 should not be used to represent HDR signal, as detailed in the introduction._
 
 ## Extend `ImageDataSettings` to support higher bit depths
 
-Add to `ImageDataSettings` a `ImageDataColorType` member that specifies the
+Add to `ImageDataSettings` a `ImageDataType` member that specifies the
 conversion semantics and type of each of the items of the `data` member array of
 `ImageData`.
 
 ```idl
   partial dictionary ImageDataSettings {
-    ImageDataColorType colorType = "Uint8ClampedArray";
+    ImageDataType dataType = "Uint8ClampedArray";
   };
 ```
 
 ```idl
-  enum ImageDataColorType {
+  enum ImageDataType {
     "unorm8",
     "float16",
     "float32"

From 399561539601c88f73a2115e2a355a05b118c7d7 Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Tue, 18 Apr 2023 22:39:46 -0700
Subject: [PATCH 14/18] Fix default value of ImageDataSettings::dataType

---
 hdr_html_canvas_element.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index eaaa019..df364ae 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -150,7 +150,7 @@ conversion semantics and type of each of the items of the `data` member array of
 
 ```idl
   partial dictionary ImageDataSettings {
-    ImageDataType dataType = "Uint8ClampedArray";
+    ImageDataType dataType = "unorm8";
   };
 ```
 

From bf420a5c503de00baa165878195d892964e9d2c0 Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Tue, 18 Apr 2023 23:09:39 -0700
Subject: [PATCH 15/18] Add details on CanvasMasteringDisplayMetadata

---
 hdr_html_canvas_element.md | 30 ++++++++++++++++++++++++------
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index df364ae..a10d1b8 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -173,7 +173,7 @@ Add a new CanvasColorMetadata dictionary:
 
 ```idl
 dictionary CanvasColorMetadata {
-  CanvasSmpteSt2086Metadata smpteSt2086Metadata;
+  CanvasMasteringDisplayMetadata masteringDisplayMetadata;
 }
 ```
 
@@ -193,14 +193,32 @@ dictionary CanvasColorMetadata {
 ```
 
 ```idl
-// SMPTE ST 2086 color volume metadata.
-dictionary CanvasSmpteSt2086Metadata {
-  ColorVolume colorVolume;
-  required float minimumLuminanceNits;
-  required float maximumLuminanceNits;
+dictionary CanvasMasteringDisplayMetadata {
+  optional ColorVolume colorVolume;
+  optional double minimumLuminance;
+  optional double maximumLuminance;
 }
 ```
 
+If present, `masteringDisplayMetadata` specifies the characteristics (the color
+primaries, white point, and luminance range) of the display that was used in
+mastering the image content. This information allows a destination display to
+optimize tone mapping based on the relationship between its own capabilities and
+those of the mastering display. [SMPTE ST
+2086:2018](https://ieeexplore.ieee.org/document/8353899) specifies the semantics
+and range of values permitted:
+* `redPrimaryX`, `redPrimaryY`, `greenPrimaryX`, `greenPrimaryY`,
+  `bluePrimaryX`, and `bluePrimaryY` are the xy coordinates, as defined in [ISO
+  11664-3](https://www.iso.org/standard/74165.html) of the nominal primaries of
+  the mastering display
+* `whitePointX` and `whitePointY` are the xy coordinates of the nominal
+  chromaticity of the white point of the mastering display
+* `minimumLuminance` and `maximumLuminance` are the nominal minimum and maximum
+  display luminance, respectively, of the mastering display in cd/m².
+
+The attributes of masteringDisplayMetadata SHOULD be set if know, e.g. if
+obtained from metadata contained in a source image, and omitted otherwise.
+
 Add a mechanism for specifying this on `CanvasRenderingContext2D` and
 `OffscreenCanvasRenderingContext2D`.
 

From 514a1e6d62753195225421de23a7c8c218890f99 Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Wed, 19 Apr 2023 09:37:57 -0700
Subject: [PATCH 16/18] Addressed
 https://github.com/w3c/ColorWeb-CG/pull/95#issuecomment-1515027411

---
 hdr_html_canvas_element.md | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index a10d1b8..637bc5c 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -287,9 +287,16 @@ function rec2020SDRLineartoSRGB(r, g, b) {
 }
 ```
 
-A demonstration of the method is provided at
+The method is demonstrated at
 <https://www.sandflow.com/public/tone-mapping/index.html>.
 
+The method requires minimum, maximum and average luminance values as input.
+These values can be determined by analyzing the image -- as it is done in the
+demonstration above. If such an analysis is not possible, the `minimumLuminance`
+and `maximumLuminance` values of `CanvasMasteringDisplayMetadata` can be used as
+approximation for  the minimum and maximum luminance values, and a value of 10
+cd/m² can be used for the average luminance.
+
 #### `rec2100-hlg` to `srgb`
 
 _Input:_ Full-range non-linear floating-point `rec2100-hlg` pixel with black at

From 62debfe29fa1dcfce853528c930373d5112a5475 Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Wed, 19 Apr 2023 17:49:30 -0700
Subject: [PATCH 17/18] Address feedback

---
 hdr_html_canvas_element.md | 43 +++++++++++++++++++++++++++++++-------
 1 file changed, 35 insertions(+), 8 deletions(-)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 637bc5c..27f236f 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -45,9 +45,10 @@ introduced in an `img` or `video` element. Example applications include:
 * drawing images retrieved from a file whose format is not supported by the
   `img` or `video` elements
 * collage of images, both HDR and SDR
-* drawing of visual elements that are related to an HDR video presentation, with
-  the expectation that the visual elements match the look of the HDR video
-  presentation.
+* adding graphics to an HDR image
+* drawing of visual elements that are related to an HDR presentation in a
+ `video` element, with the expectation that the former match the look of the
+ latter.
 
 ## Scope
 
@@ -62,6 +63,8 @@ This proposal:
 * does not preclude adding other HDR capabilities to HTML Canvas, such as
   support for additional color spaces like a linear high-dynamic range color
   space.
+* neither specifies nor requires new capabilities for compositing `canvas`
+  elements with other HTML elements.
 
 ## Add color spaces intended for use with HDR images
 
@@ -72,8 +75,12 @@ include the following color spaces.
 
 ```idl
   partial enum PredefinedColorSpace {
-    'rec2100-hlg',
-    'rec2100-pq',
+    /*
+     * Currently defined values: "srgb", "display-p3"
+     */
+
+    "rec2100-hlg",
+    "rec2100-pq",
   }
 ```
 
@@ -120,6 +127,15 @@ specifies the representation of each pixel of the [output bitmap](https://html.s
 
 ```idl
   partial dictionary CanvasRenderingContext2DSettings {
+    /*
+     * Currently defined attributes:
+     *
+     * boolean alpha = true;
+     * boolean desynchronized = false;
+     * PredefinedColorSpace colorSpace = "srgb";
+     * boolean willReadFrequently = false;
+     */
+
     CanvasDataType dataType = "unorm8";
   };
 ```
@@ -144,12 +160,19 @@ should not be used to represent HDR signal, as detailed in the introduction._
 
 ## Extend `ImageDataSettings` to support higher bit depths
 
-Add to `ImageDataSettings` a `ImageDataType` member that specifies the
-conversion semantics and type of each of the items of the `data` member array of
-`ImageData`.
+Add to
+[`ImageDataSettings`](https://html.spec.whatwg.org/multipage/canvas.html#imagedatasettings)
+a `ImageDataType` member that specifies the conversion semantics and type of
+each of the items of the `data` member array of `ImageData`.
 
 ```idl
   partial dictionary ImageDataSettings {
+    /*
+     * Currently defined attributes:
+     *
+     * PredefinedColorSpace colorSpace;
+     */
+
     ImageDataType dataType = "unorm8";
   };
 ```
@@ -167,6 +190,10 @@ The values `"unorm8"`, `"float16"` and `"float32"` result in `data` returning an
 array with the type `Uint8ClampedArray`, `Float16Array`, `Float32Array`,
 respectively.
 
+_NOTE: The strawman requires at least one of `"float16"` and `"float32"` to
+support HDR imagery. Both are listed above to emphasize that the strawman can
+work with both or either.
+
 ## Add HDR rendering behavior and HDR metadata to `CanvasRenderingContext2DSettings`
 
 Add a new CanvasColorMetadata dictionary:

From 380d4a74eff227f31a4ed3c958398842bbf2c507 Mon Sep 17 00:00:00 2001
From: Pierre-Anthony Lemieux <pal@palemieux.com>
Date: Wed, 19 Apr 2023 20:31:32 -0700
Subject: [PATCH 18/18] Add note re: practices when drawing images with
 different color volume on the same HTML Canvas

---
 hdr_html_canvas_element.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/hdr_html_canvas_element.md b/hdr_html_canvas_element.md
index 27f236f..331d2c5 100644
--- a/hdr_html_canvas_element.md
+++ b/hdr_html_canvas_element.md
@@ -255,6 +255,10 @@ Add a mechanism for specifying this on `CanvasRenderingContext2D` and
   }
 ```
 
+_NOTE:_ See <https://github.com/w3c/ColorWeb-CG/issues/97> for an open issue discussing
+practices when drawing images with different color volume on the same HTML
+Canvas.
+
 ## Annex A: Color space conversions
 
 ### Background