Decode HEIF Exif and XMP metadata

HEIF_IMPLEMENTATION_PLAN.md

@@ -89,6 +89,7 @@ This snapshot pins or classifies the available references and failures; it does
 | `HeifConstants.IsSupportedFileType`, `HeifImageFormatDetector`, and `HeifDecoderCore.CheckFileTypeBox` | ISO/IEC 14496-12 `FileTypeBox` syntax and the MP4 Registration Authority HEIF/AVIF still-image and sequence brand registrations | libavif `src/read.c` functions `avifParseFileTypeBox`, `avifFileTypeHasBrand`, and `avifFileTypeIsCompatible` at `092276ce89098ead06db80975173191e5fee1826` | Apply one rule to the major and compatible brands, accept the implemented still-image container and payload brands, and reject registered HEVC, AVIF, and JPEG sequence major brands as outside the image-item scope. The decoder validates the complete `ftyp` payload; the fixed-size format detector inspects the available prefix. |
 | `HeifDecoderCore.ReadBoxHeader` and `HeifDecoderCore.ParseBoxHeader` | ISO/IEC 14496-12 section 4.2.2 basic box syntax | libavif `src/stream.c` functions `avifROStreamReadBoxHeaderPartial` and `avifROStreamReadBoxHeader` at `092276ce89098ead06db80975173191e5fee1826` | Resolve 32-bit, 64-bit, UUID, and top-level size-zero boxes into content lengths only after validating the complete variable-sized header and the remaining parent boundary. Nested size-zero boxes are invalid; large skips retain 64-bit offsets. |
 | `HeifDecoderCore.ParseMetadata` | ISO/IEC 14496-12 `MetaBox` and HEIF item declarations, locations, properties, and associations | libavif `src/read.c` functions `avifParseMetaBox`, `avifMetaFindOrCreateItem`, `avifParseItemLocationBox`, and `avifParseItemPropertiesBox` at `092276ce89098ead06db80975173191e5fee1826` | Index unique recognized metadata children by type and payload location, then parse them in dependency order so physical placement does not control item lookup or property association. Duplicate unique children and truncated full-box headers are invalid. |
+| `HeifDecoderCore.ApplyAssociatedMetadata` | HEIF Annex A Exif item data, MIME metadata items, and `cdsc` item references | libavif `src/read.c` function `avifDecoderFindMetadata`, `src/exif.c` function `avifGetExifTiffHeaderOffset`, and the Exif/XMP item writing paths in `src/write.c` at `092276ce89098ead06db80975173191e5fee1826` | Resolve only metadata items whose `cdsc` reference identifies the decoded primary image, validate the Exif TIFF-header offset, and attach Exif or `application/rdf+xml` XMP through ImageSharp's existing profile types. This is a bounded still-image metadata path; it does not introduce a generic ISO BMFF metadata, media, or track model. |
 | `GridHeifItemDecoder` and `HeifDecoderCore` grid/thumbnail selection | ISO/IEC 23008-12 section 6.6.2.3 image-grid syntax and MIAF grid-cell constraints | libavif `src/read.c` functions `avifParseImageGridBox`, `avifDecoderDataAllocateImagePlanes`, and `avifDecoderDataCopyTileToImage` at `092276ce89098ead06db80975173191e5fee1826` | Parse version-zero 16-bit and 32-bit grid descriptors, preserve row-major `dimg` order, require the declared tile count and one coding format, validate canvas coverage and edge overlap, and crop only the rightmost column and bottom row while copying through ImageSharp pixel buffers. A primary grid whose tile codec is unavailable may use only a decodable thumbnail that explicitly references that grid. |
 | `HeifDecoderCore` alpha auxiliary selection/composition and `GridHeifItemDecoder` auxiliary tile ordering | ISO/IEC 23008-12 alpha auxiliary image semantics, `auxC`, `auxl`, `prem`, and per-grid-tile alpha relationships | libavif `src/read.c` functions `avifParseAuxiliaryTypeProperty`, `avifDecoderItemIsAlphaAux`, `avifMetaFindAlphaItem`, and `avifDecoderCheckAlphaProperties`, plus `src/scale.c` box-filter scaling at `092276ce89098ead06db80975173191e5fee1826` | Recognize both registered alpha URNs, decode a direct alpha image/grid or the complete row-major set of per-color-tile alpha auxiliaries, normalize through `L16`, box-resample differing auxiliary dimensions, compose through `Rgba64` and `PixelOperations<TPixel>`, and unassociate `prem` color samples with transparent-black handling. This remains an image-item relationship only; no track or generic media-reference model is introduced. |
 
@@ -117,7 +118,8 @@ This assessment is based on the current source after the upstream ImageSharp mer
 - Grid derived-image decoding now parses both registered descriptor widths, resolves the ordered `dimg` cells, validates tile count, coding format, dimensions, canvas coverage, and edge overlap, then composes the output through ImageSharp row buffers. Unsupported grid tile codecs can select only a decodable thumbnail of the same primary grid. Independent AV1 and JPEG grid fixtures are still required, and HEVC grids remain blocked on the HEVC decoder.
 - Alpha auxiliary decoding now recognizes `auxC`, `auxl`, and `prem`, supports a direct auxiliary image/grid and the per-color-grid-tile form, preserves normalized alpha through `L16`/`Rgba64`, box-resamples differing plane sizes, and reports alpha presence. HEVC alpha remains blocked on the HEVC image-item decoder, while independent AVIF alpha fixtures are still required against the incomplete AV1 reconstruction pipeline.
 - Clean aperture, image rotation, and image mirror properties now validate their registered payloads, exact integer crop geometry, and essential associations; affect Identify dimensions; and reuse ImageSharp's optimized crop/rotate/flip processors after auxiliary alpha composition in the MIAF-defined order. Independent transform vectors must still verify every crop/rotation/mirror/alpha combination.
-- HEVC and AV1 configuration, CICP color information, Exif/XMP, and several image-item properties/relationships are missing or parsed without affecting output.
+- Decode now resolves `cdsc`-associated Exif and `application/rdf+xml` XMP items for the primary still image, validates the declared Exif TIFF-header offset, and attaches the payloads through ImageSharp's existing profile types before presentation transforms. Independent AVIF, HEIC, and HIF metadata fixtures and Identify-time profile reporting remain required.
+- HEVC and AV1 configuration, ICC/CICP color information, pixel aspect ratio, and several image-item properties/relationships are missing or parsed without fully affecting output.
 - Identify and decode now use the same bounded metadata parser and both validate the complete leading file type box. The parsed state is still mutable and Identify does not yet report the complete bit depth, color, profile, or transform model.
 
 ### HEVC decoder and encoder

src/ImageSharp/Formats/Heif/HeifDecoderCore.cs

@@ -9,7 +9,9 @@ using SixLabors.ImageSharp.Formats.Heif.Av1;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
 
@@ -1317,6 +1319,11 @@ internal sealed class HeifDecoderCore : ImageDecoderCore
                 this.ApplyAlpha(image, alphaImage, alphaPremultiplied);
             }
 
+            if (!this.Options.SkipMetadata)
+            {
+                this.ApplyAssociatedMetadata(image.Metadata, rootItem, buffers);
+            }
+
             // MIAF defines crop, rotation, and mirror as presentation operations in that order. Applying the
             // implemented transforms after alpha composition keeps the auxiliary plane in the same coordinate space.
             ApplyPresentationTransforms(image, itemToDecode);
@@ -1336,6 +1343,81 @@ internal sealed class HeifDecoderCore : ImageDecoderCore
         }
     }
 
+    /// <summary>
+    /// Applies Exif and XMP metadata items that describe a decoded color image item.
+    /// </summary>
+    /// <param name="metadata">The decoded image metadata receiving the profiles.</param>
+    /// <param name="colorItem">The color image item described by the metadata links.</param>
+    /// <param name="buffers">The assembled payloads for the container's declared items.</param>
+    private void ApplyAssociatedMetadata(
+        ImageMetadata metadata,
+        HeifItem colorItem,
+        DisposableDictionary<uint, IMemoryOwner<byte>> buffers)
+    {
+        foreach (HeifItemLink link in this.itemLinks)
+        {
+            if (link.Type != Heif4CharCode.Cdsc || !link.DestinationIds.Contains(colorItem.Id))
+            {
+                continue;
+            }
+
+            HeifItem? metadataItem = this.FindItemById(link.SourceId);
+            if (metadataItem is null || !buffers.TryGetValue(metadataItem.Id, out IMemoryOwner<byte>? itemMemory))
+            {
+                continue;
+            }
+
+            byte[] itemData = itemMemory.GetSpan().ToArray();
+            if (metadataItem.Type == Heif4CharCode.Exif)
+            {
+                this.ExecuteAncillarySegmentAction(() =>
+                {
+                    if (itemData.Length < 8)
+                    {
+                        throw new InvalidImageContentException("The HEIF Exif item is truncated.");
+                    }
+
+                    uint declaredTiffHeaderOffset = BinaryPrimitives.ReadUInt32BigEndian(itemData);
+                    Span<byte> exifData = itemData.AsSpan(4);
+                    int actualTiffHeaderOffset = -1;
+
+                    // Annex A stores the offset to the first TIFF byte-order marker. Match libavif by finding the
+                    // first valid TIFF signature and requiring the declared offset to identify that same header.
+                    for (int i = 0; i <= exifData.Length - 4; i++)
+                    {
+                        bool isBigEndianTiff = exifData[i] == (byte)'M' &&
+                            exifData[i + 1] == (byte)'M' &&
+                            exifData[i + 2] == 0 &&
+                            exifData[i + 3] == 42;
+
+                        bool isLittleEndianTiff = exifData[i] == (byte)'I' &&
+                            exifData[i + 1] == (byte)'I' &&
+                            exifData[i + 2] == 42 &&
+                            exifData[i + 3] == 0;
+
+                        if (isBigEndianTiff || isLittleEndianTiff)
+                        {
+                            actualTiffHeaderOffset = i;
+                            break;
+                        }
+                    }
+
+                    if (actualTiffHeaderOffset < 0 || declaredTiffHeaderOffset != (uint)actualTiffHeaderOffset)
+                    {
+                        throw new InvalidImageContentException("The HEIF Exif item has an invalid TIFF-header offset.");
+                    }
+
+                    metadata.ExifProfile = new ExifProfile(exifData[actualTiffHeaderOffset..].ToArray());
+                });
+            }
+            else if (metadataItem.Type == Heif4CharCode.Mime &&
+                string.Equals(metadataItem.ContentType, "application/rdf+xml", StringComparison.Ordinal))
+            {
+                this.ExecuteAncillarySegmentAction(() => metadata.XmpProfile = new XmpProfile(itemData));
+            }
+        }
+    }
+
     /// <summary>
     /// Selects the registered coded-image or grid decoder for an image item.
     /// </summary>