HDR

  Known limitations of this prototype:
  1. Resize still runs in gamma space (gift library), not linear-light PQ. For HDR you'd ideally resize in
   linear, then re-encode to PQ. Visible difference is usually subtle but worth a follow-up.
  2. The non-gain-map HDR path (true PQ source like netflix-reencoded.avif) is unchanged — already worked.
  3. Quality of the bake depends on gainMap->alternateHdrHeadroom; if a Lightroom export sets this to 0
  we'd silently fall to SDR-equivalent. Worth a sanity check if you hit such a file.

  Worth opening in Safari on an HDR-capable Mac and comparing against the original straws.avif to confirm
  the highlights pop the way you expect.

Author: bep

hugolib/site.go

@@ -209,7 +209,7 @@ func NewHugoSites(cfg deps.DepsCfg) (*HugoSites, error) {
 	if n := config.GetNumWorkerMultiplier(); n > 1 {
 		poolSizeKatex = min(n, 8)
 		poolSizeWebP = max(2, n/2)
-		poolSizeAvif = max(2, n/2)
+		poolSizeAvif = max(3, n/2)
 	}
 
 	var logger loggers.Logger

internal/warpc/avif.go

@@ -145,6 +145,8 @@ func (d *AvifCodec) Decode(r io.Reader) (image.Image, error) {
 			colorPrimaries:          out.Data.Params.ColorPrimaries,
 			transferCharacteristics: out.Data.Params.TransferCharacteristics,
 			matrixCoefficients:      out.Data.Params.MatrixCoefficients,
+			maxCLL:                  out.Data.Params.MaxCLL,
+			maxPALL:                 out.Data.Params.MaxPALL,
 		}
 
 		frameSize := stride * h
@@ -188,6 +190,8 @@ func (d *AvifCodec) Decode(r io.Reader) (image.Image, error) {
 			colorPrimaries:          out.Data.Params.ColorPrimaries,
 			transferCharacteristics: out.Data.Params.TransferCharacteristics,
 			matrixCoefficients:      out.Data.Params.MatrixCoefficients,
+			maxCLL:                  out.Data.Params.MaxCLL,
+			maxPALL:                 out.Data.Params.MaxPALL,
 		}
 		return img, nil
 	}
@@ -224,6 +228,8 @@ func (d *AvifCodec) Encode(w io.Writer, src image.Image, options map[string]any)
 		params["colorPrimaries"] = img.GetColorPrimaries()
 		params["transferCharacteristics"] = img.GetTransferCharacteristics()
 		params["matrixCoefficients"] = img.GetMatrixCoefficients()
+		params["maxCLL"] = img.GetMaxCLL()
+		params["maxPALL"] = img.GetMaxPALL()
 
 		// Handle the first frame based on its type.
 		firstFrame := frames[0]

internal/warpc/avif_color_test.go

@@ -15,7 +15,9 @@ func TestAvifColorPropertyPreservation(t *testing.T) {
 		t.Skip("Skipping in short mode")
 	}
 
-	// Test that dock.avif (BT.709/sRGB) maintains its color properties when re-encoded
+	// dock-75-hdr.avif is Lightroom-style SDR+gain-map HDR; the decoder bakes the
+	// gain map into a single BT.2020/PQ HDR AVIF. netflix-reencoded.avif is already
+	// a true HDR PQ AVIF and round-trips with its CICP intact.
 	files := `
 -- hugo.toml --
 -- assets/dock.avif --
@@ -59,10 +61,10 @@ NetflixReencoded: {{ $netflixReencoded.RelPermalink }}
 	publicDir := filepath.Join(b.Cfg.WorkingDir, "public")
 	t.Logf("Looking in: %s", publicDir)
 
-	// dock.avif should remain BT.709/sRGB
+	// dock-75-hdr.avif has a gain map, so the output should be BT.2020/PQ.
 	dockMatches, _ := filepath.Glob(filepath.Join(publicDir, "dock_hu*.avif"))
 	if len(dockMatches) > 0 {
-		checkColorProps(t, "dock", dockMatches[0], "BT.709", "sRGB")
+		checkColorProps(t, "dock", dockMatches[0], "BT.2020", "PQ")
 	} else {
 		t.Error("No dock AVIF file found in output")
 	}

internal/warpc/genavif/avif.c

@@ -39,6 +39,10 @@ typedef struct
     int transferCharacteristics;
     int matrixCoefficients;
 
+    // HDR CLLI box (max content/picture-average light level, in cd/m^2).
+    int maxCLL;
+    int maxPALL;
+
 } InputParams;
 
 typedef struct
@@ -123,6 +127,8 @@ InputMessage parse_input_message(const char *line)
             msg.data.params.colorPrimaries = (int)json_object_get_number(params_object, "colorPrimaries");
             msg.data.params.transferCharacteristics = (int)json_object_get_number(params_object, "transferCharacteristics");
             msg.data.params.matrixCoefficients = (int)json_object_get_number(params_object, "matrixCoefficients");
+            msg.data.params.maxCLL = (int)json_object_get_number(params_object, "maxCLL");
+            msg.data.params.maxPALL = (int)json_object_get_number(params_object, "maxPALL");
             JSON_Array *durations_array = json_object_get_array(params_object, "frameDurations");
             if (durations_array != NULL)
             {
@@ -209,6 +215,8 @@ void write_output_message(const OutputMessage *msg)
         json_object_set_number(params_object, "colorPrimaries", msg->data.params.colorPrimaries);
         json_object_set_number(params_object, "transferCharacteristics", msg->data.params.transferCharacteristics);
         json_object_set_number(params_object, "matrixCoefficients", msg->data.params.matrixCoefficients);
+        json_object_set_number(params_object, "maxCLL", msg->data.params.maxCLL);
+        json_object_set_number(params_object, "maxPALL", msg->data.params.maxPALL);
         if (msg->data.params.frameDurations != NULL)
         {
             JSON_Value *durations_value = json_value_init_array();
@@ -292,6 +300,8 @@ void handle_commands(FILE *stream)
             decoder->ignoreExif = AVIF_TRUE;
             decoder->ignoreXMP = AVIF_TRUE;
             decoder->maxThreads = 1;
+            // Request gain map pixels when present (e.g. Lightroom HDR exports).
+            decoder->imageContentToDecode = AVIF_IMAGE_CONTENT_ALL;
 
             avifResult result = avifDecoderSetIOMemory(decoder, blob_data, blob_size);
             if (result != AVIF_RESULT_OK)
@@ -311,6 +321,84 @@ void handle_commands(FILE *stream)
                 goto cleanup;
             }
 
+            // If a gain map is present (e.g. Adobe-style SDR+gainmap HDR from Lightroom),
+            // bake it into a single true-HDR image in BT.2020/PQ at 10-bit.
+            // The downstream pipeline then sees a normal HDR AVIF; SDR clients/displays
+            // tone-map automatically.
+            avifBool hasGainMap = (decoder->image->gainMap != NULL && decoder->image->gainMap->image != NULL);
+            if (hasGainMap)
+            {
+                // Need a full frame to apply the gain map.
+                result = avifDecoderNextImage(decoder);
+                if (result != AVIF_RESULT_OK)
+                {
+                    snprintf(output.header.err, sizeof(output.header.err), "Failed to decode AVIF for gain map: %s", avifResultToString(result));
+                    avifDecoderDestroy(decoder);
+                    write_output_message(&output);
+                    goto cleanup;
+                }
+
+                avifRGBImage outRGB;
+                memset(&outRGB, 0, sizeof(outRGB));
+                avifRGBImageSetDefaults(&outRGB, decoder->image);
+                outRGB.format = AVIF_RGB_FORMAT_RGBA;
+                outRGB.depth = 16;
+                if (avifRGBImageAllocatePixels(&outRGB) != AVIF_RESULT_OK)
+                {
+                    snprintf(output.header.err, sizeof(output.header.err), "Failed to allocate RGB pixels for gain map apply");
+                    avifDecoderDestroy(decoder);
+                    write_output_message(&output);
+                    goto cleanup;
+                }
+
+                // Target the alternate (full-HDR) endpoint: alternateHdrHeadroom = log2(HDR/SDR).
+                float hdrHeadroom = 0.0f;
+                const avifUnsignedFraction *h = &decoder->image->gainMap->alternateHdrHeadroom;
+                if (h->d != 0)
+                {
+                    hdrHeadroom = (float)h->n / (float)h->d;
+                }
+
+                avifContentLightLevelInformationBox outCLLI = {0};
+                avifResult applyResult = avifImageApplyGainMap(
+                    decoder->image,
+                    decoder->image->gainMap,
+                    hdrHeadroom,
+                    AVIF_COLOR_PRIMARIES_BT2020,
+                    AVIF_TRANSFER_CHARACTERISTICS_PQ,
+                    &outRGB,
+                    &outCLLI,
+                    NULL);
+                if (applyResult != AVIF_RESULT_OK)
+                {
+                    snprintf(output.header.err, sizeof(output.header.err), "Failed to apply gain map: %s", avifResultToString(applyResult));
+                    avifRGBImageFreePixels(&outRGB);
+                    avifDecoderDestroy(decoder);
+                    write_output_message(&output);
+                    goto cleanup;
+                }
+
+                output.data.params.width = outRGB.width;
+                output.data.params.height = outRGB.height;
+                // Tell the Go side we're 10-bit HDR so it wraps in NRGBA64 and re-encodes as HDR.
+                output.data.params.depth = 10;
+                output.data.params.stride = outRGB.rowBytes;
+                output.data.params.frameCount = 1;
+                output.data.params.colorPrimaries = AVIF_COLOR_PRIMARIES_BT2020;
+                output.data.params.transferCharacteristics = AVIF_TRANSFER_CHARACTERISTICS_PQ;
+                output.data.params.matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT2020_NCL;
+                output.data.params.maxCLL = outCLLI.maxCLL;
+                output.data.params.maxPALL = outCLLI.maxPALL;
+
+                size_t blob_out_size = (size_t)outRGB.rowBytes * outRGB.height;
+                write_output_message(&output);
+                write_blob(output.header.id, outRGB.pixels, blob_out_size);
+
+                avifRGBImageFreePixels(&outRGB);
+                avifDecoderDestroy(decoder);
+                goto cleanup;
+            }
+
             // YUV420 (4:2:0) and YUV422 (4:2:2) chroma subsampling cause issues in WASM.
             // Only YUV444 (4:4:4) is currently supported.
             if (decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420 ||
@@ -511,13 +599,19 @@ void handle_commands(FILE *stream)
             }
             image->yuvRange = AVIF_RANGE_FULL;
 
+            // CLLI carries HDR peak/avg light levels from a baked gain map.
+            if (input.data.params.maxCLL > 0 || input.data.params.maxPALL > 0) {
+                image->clli.maxCLL = (uint16_t)input.data.params.maxCLL;
+                image->clli.maxPALL = (uint16_t)input.data.params.maxPALL;
+            }
+
             avifRGBImage rgb;
             avifRGBImageSetDefaults(&rgb, image);
             rgb.format = AVIF_RGB_FORMAT_RGBA;
             rgb.depth = rgb_depth;
             rgb.pixels = (uint8_t *)blob_data;
             rgb.rowBytes = stride;
-            
+
             avifResult result = avifImageRGBToYUV(image, &rgb);
             if (result != AVIF_RESULT_OK) {
                 snprintf(output.header.err, sizeof(output.header.err), "encodeNRGBA: Failed to convert to YUV: %s", avifResultToString(result));
@@ -625,6 +719,11 @@ void handle_commands(FILE *stream)
             }
             image->yuvRange = AVIF_RANGE_FULL;
 
+            if (input.data.params.maxCLL > 0 || input.data.params.maxPALL > 0) {
+                image->clli.maxCLL = (uint16_t)input.data.params.maxCLL;
+                image->clli.maxPALL = (uint16_t)input.data.params.maxPALL;
+            }
+
             avifResult alloc_result = avifImageAllocatePlanes(image, AVIF_PLANES_YUV);
             if (alloc_result != AVIF_RESULT_OK) {
                 snprintf(output.header.err, sizeof(output.header.err), "encodeGray: Failed to allocate planes: %s", avifResultToString(alloc_result));

internal/warpc/wasm/avif.wasm

@@ -48,6 +48,11 @@ type CommonImageProcessingParams struct {
 	ColorPrimaries          int `json:"colorPrimaries,omitempty"`
 	TransferCharacteristics int `json:"transferCharacteristics,omitempty"`
 	MatrixCoefficients      int `json:"matrixCoefficients,omitempty"`
+
+	// HDR CLLI box (cd/m^2). Populated by the AVIF decoder when a gain map has
+	// been baked into a PQ HDR image, and re-applied by the encoder.
+	MaxCLL  int `json:"maxCLL,omitempty"`
+	MaxPALL int `json:"maxPALL,omitempty"`
 }
 
 /*
@@ -374,6 +379,10 @@ type AnimatedImage struct {
 	colorPrimaries          int
 	transferCharacteristics int
 	matrixCoefficients      int
+
+	// HDR CLLI (cd/m^2). Set when an AVIF gain map has been baked into PQ HDR.
+	maxCLL  int
+	maxPALL int
 }
 
 func (w *AnimatedImage) GetLoopCount() int {
@@ -408,6 +417,14 @@ func (w *AnimatedImage) GetMatrixCoefficients() int {
 	return w.matrixCoefficients
 }
 
+func (w *AnimatedImage) GetMaxCLL() int {
+	return w.maxCLL
+}
+
+func (w *AnimatedImage) GetMaxPALL() int {
+	return w.maxPALL
+}
+
 func (w *AnimatedImage) SetFrames(frames []image.Image) {
 	if len(frames) == 0 {
 		panic("frames cannot be empty")

internal/warpc/webp.go

@@ -67,7 +67,7 @@ type Codec struct {
 
 // TODO1 remove this.
 func stopClock(what string, start time.Time) {
-	fmt.Printf("%q: %s\n", what, time.Since(start))
+	fmt.Printf("%-10s %s\n", what, time.Since(start))
 }
 
 func newCodec(webp, avif EncodeDecoder, debugl logg.LevelLogger) *Codec {
@@ -76,7 +76,7 @@ func newCodec(webp, avif EncodeDecoder, debugl logg.LevelLogger) *Codec {
 
 func (d *Codec) EncodeTo(conf ImageConfig, w io.Writer, img image.Image) error {
 	start := time.Now()
-	defer stopClock("Encode", start)
+	defer stopClock(fmt.Sprintf("Encode %s", conf.TargetFormat.String()), start)
 	d.debugl.Log(
 		// This construct looks odd, but the func will only be called if debug is enabled.
 		logg.StringFunc(
@@ -172,7 +172,7 @@ func (d *Codec) EncodeTo(conf ImageConfig, w io.Writer, img image.Image) error {
 
 func (d *Codec) DecodeFormat(f Format, r io.Reader) (image.Image, error) {
 	start := time.Now()
-	defer stopClock("Decode", start)
+	defer stopClock(fmt.Sprintf("Decode %s", f.String()), start)
 	d.debugl.Log(
 		logg.StringFunc(
 			func() string {
@@ -231,7 +231,6 @@ func (d *Codec) DecodeFormat(f Format, r io.Reader) (image.Image, error) {
 
 func (d *Codec) Decode(r io.Reader) (image.Image, error) {
 	start := time.Now()
-	defer stopClock("Decode", start)
 	d.debugl.Log(
 		logg.StringFunc(
 			func() string {
@@ -245,6 +244,7 @@ func (d *Codec) Decode(r io.Reader) (image.Image, error) {
 		return nil, err
 	}
 	if format != 0 {
+		defer stopClock("Decode "+format.String(), start)
 		return d.DecodeFormat(format, rr)
 	}
 

resources/images/codec.go

@@ -356,8 +356,6 @@ func TestImagesGoldenProcessAvif(t *testing.T) {
 	// Will be used as the base folder for generated images.
 	name := "process/avif"
 
-	// TODO(bep) investigate why the Netflix originals crashes.
-
 	files := `
 -- hugo.toml --
 -- assets/dock.avif --
@@ -383,7 +381,38 @@ Home.
 	opts.T = t
 	opts.Name = name
 	opts.Files = files
-	opts.WriteFiles = true
+	opts.WriteFiles = true // TODO1
+
+	imagetesting.RunGolden(opts)
+}
+
+func TestImagesGoldenProcessAviStraws(t *testing.T) {
+	t.Parallel()
+
+	if imagetesting.SkipGoldenTests {
+		t.Skip("Skip golden test on this architecture")
+	}
+
+	// Will be used as the base folder for generated images.
+	name := "process/avifstraws"
+
+	files := `
+-- hugo.toml --
+-- assets/straws.avif --
+sourcefilename: ../testdata/bep/straws.avif
+-- layouts/home.html --
+Home.
+{{ $straws := resources.Get "straws.avif" }}
+{{ template "process" (dict "spec" "resize 900x" "img" $straws) }}
+
+
+` + goldenProcess
+
+	opts := imagetesting.DefaultGoldenOpts
+	opts.T = t
+	opts.Name = name
+	opts.Files = files
+	opts.WriteFiles = true // TODO1
 
 	imagetesting.RunGolden(opts)
 }