Added support for loading exif data from PNG "Raw profile type exif" text chunk

src/ImageSharp/Formats/Png/PngDecoderCore.cs

@@ -124,6 +124,12 @@ public PngDecoderCore(Configuration configuration, IPngDecoderOptions options)
             this.ignoreMetadata = options.IgnoreMetadata;
         }
 
+        /// <summary>
+        /// Gets the sequence of bytes for the exif header ("Exif" ASCII and two zero bytes). Used for the legacy exif parsing.
+        /// </summary>
+        // This uses C# compiler's optimization to refer to the static data directly, no intermediate array allocations happen.
+        private static ReadOnlySpan<byte> ExifHeader => new byte[] { 0x45, 0x78, 0x69, 0x66, 0x00, 0x00 };
+
         /// <inheritdoc/>
         public Configuration Configuration { get; }
 
@@ -182,7 +188,7 @@ public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken
                                 this.ReadTextChunk(pngMetadata, chunk.Data.GetSpan());
                                 break;
                             case PngChunkType.CompressedText:
-                                this.ReadCompressedTextChunk(pngMetadata, chunk.Data.GetSpan());
+                                this.ReadCompressedTextChunk(metadata, pngMetadata, chunk.Data.GetSpan());
                                 break;
                             case PngChunkType.InternationalText:
                                 this.ReadInternationalTextChunk(pngMetadata, chunk.Data.GetSpan());
@@ -192,7 +198,7 @@ public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken
                                 {
                                     var exifData = new byte[chunk.Length];
                                     chunk.Data.GetSpan().CopyTo(exifData);
-                                    metadata.ExifProfile = new ExifProfile(exifData);
+                                    this.MergeOrSetExifProfile(metadata, new ExifProfile(exifData), replaceExistingKeys: true);
                                 }
 
                                 break;
@@ -255,7 +261,7 @@ public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancella
                                 this.ReadTextChunk(pngMetadata, chunk.Data.GetSpan());
                                 break;
                             case PngChunkType.CompressedText:
-                                this.ReadCompressedTextChunk(pngMetadata, chunk.Data.GetSpan());
+                                this.ReadCompressedTextChunk(metadata, pngMetadata, chunk.Data.GetSpan());
                                 break;
                             case PngChunkType.InternationalText:
                                 this.ReadInternationalTextChunk(pngMetadata, chunk.Data.GetSpan());
@@ -265,7 +271,7 @@ public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancella
                                 {
                                     var exifData = new byte[chunk.Length];
                                     chunk.Data.GetSpan().CopyTo(exifData);
-                                    metadata.ExifProfile = new ExifProfile(exifData);
+                                    this.MergeOrSetExifProfile(metadata, new ExifProfile(exifData), replaceExistingKeys: true);
                                 }
 
                                 break;
@@ -937,9 +943,10 @@ private void ReadTextChunk(PngMetadata metadata, ReadOnlySpan<byte> data)
         /// <summary>
         /// Reads the compressed text chunk. Contains a uncompressed keyword and a compressed text string.
         /// </summary>
+        /// <param name="baseMetadata">The <see cref="ImageMetadata"/> object.</param>
         /// <param name="metadata">The metadata to decode to.</param>
         /// <param name="data">The <see cref="T:Span"/> containing the data.</param>
-        private void ReadCompressedTextChunk(PngMetadata metadata, ReadOnlySpan<byte> data)
+        private void ReadCompressedTextChunk(ImageMetadata baseMetadata, PngMetadata metadata, ReadOnlySpan<byte> data)
         {
             if (this.ignoreMetadata)
             {
@@ -971,6 +978,200 @@ private void ReadCompressedTextChunk(PngMetadata metadata, ReadOnlySpan<byte> da
             {
                 metadata.TextData.Add(new PngTextData(name, uncompressed, string.Empty, string.Empty));
             }
+
+            if (name.Equals("Raw profile type exif", StringComparison.OrdinalIgnoreCase))
+            {
+                this.ReadLegacyExifTextChunk(baseMetadata, uncompressed);
+            }
+        }
+
+        /// <summary>
+        /// Reads exif data encoded into a text chunk with the name "raw profile type exif".
+        /// This method was used by ImageMagick, exiftool, exiv2, digiKam, etc, before the
+        /// 2017 update to png that allowed a true exif chunk.
+        /// </summary>
+        /// <param name="metadata">The <see cref="ImageMetadata"/> to store the decoded exif tags into.</param>
+        /// <param name="data">The contents of the "raw profile type exif" text chunk.</param>
+        private void ReadLegacyExifTextChunk(ImageMetadata metadata, string data)
+        {
+            ReadOnlySpan<char> dataSpan = data.AsSpan();
+            dataSpan = dataSpan.TrimStart();
+
+            if (!StringEquals(dataSpan.Slice(0, 4), "exif".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                // "exif" identifier is missing from the beginning of the text chunk
+                return;
+            }
+
+            // Skip to the data length
+            dataSpan = dataSpan.Slice(4).TrimStart();
+            int dataLengthEnd = dataSpan.IndexOf('\n');
+            int dataLength = ParseInt32(dataSpan.Slice(0, dataSpan.IndexOf('\n')));
+
+            // Skip to the hex-encoded data
+            dataSpan = dataSpan.Slice(dataLengthEnd).Trim();
+
+            if (dataLength < ExifHeader.Length)
+            {
+                // Not enough room for the required exif header, this data couldn't possibly be valid
+                return;
+            }
+
+            // Parse the hex-encoded data into the byte array we are going to hand off to ExifProfile
+            byte[] exifBlob = new byte[dataLength - ExifHeader.Length];
+
+            try
+            {
+                // Check for the presence of the exif header in the hex-encoded binary data
+                byte[] tempExifBuf = exifBlob;
+                if (exifBlob.Length < ExifHeader.Length)
+                {
+                    // Need to allocate a temporary array, this should be an extremely uncommon (TODO: impossible?) case
+                    tempExifBuf = new byte[ExifHeader.Length];
+                }
+
+                HexStringToBytes(dataSpan.Slice(0, ExifHeader.Length * 2), tempExifBuf.AsSpan());
+                if (!tempExifBuf.AsSpan().Slice(0, ExifHeader.Length).SequenceEqual(ExifHeader))
+                {
+                    // Exif header in the hex data is not valid
+                    return;
+                }
+
+                // Skip over the exif header we just tested
+                dataSpan = dataSpan.Slice(ExifHeader.Length * 2);
+                dataLength -= ExifHeader.Length;
+
+                // Load the hex-encoded data, one line at a time
+                for (int i = 0; i < dataLength;)
+                {
+                    ReadOnlySpan<char> lineSpan = dataSpan;
+
+                    int newlineIndex = dataSpan.IndexOf('\n');
+                    if (newlineIndex != -1)
+                    {
+                        lineSpan = dataSpan.Slice(0, newlineIndex);
+                    }
+
+                    i += HexStringToBytes(lineSpan, exifBlob.AsSpan().Slice(i));
+
+                    dataSpan = dataSpan.Slice(newlineIndex + 1);
+                }
+            }
+            catch
+            {
+                return;
+            }
+
+            this.MergeOrSetExifProfile(metadata, new ExifProfile(exifBlob), replaceExistingKeys: false);
+        }
+
+        private static bool StringEquals(ReadOnlySpan<char> span1, ReadOnlySpan<char> span2, StringComparison comparisonType)
+        {
+#pragma warning disable IDE0022 // Use expression body for methods
+#if NETSTANDARD2_1 || NETCOREAPP2_1_OR_GREATER
+            return span1.Equals(span2, comparisonType);
+#else
+            return span1.ToString().Equals(span2.ToString(), comparisonType);
+#endif
+#pragma warning restore IDE0022 // Use expression body for methods
+        }
+
+        /// <summary>
+        /// int.Parse() a ReadOnlySpan&lt;char&gt;, with a fallback for older frameworks.
+        /// </summary>
+        /// <param name="span">The <see cref="int"/> to parse.</param>
+        /// <param name="style">The <see cref="System.Globalization.NumberStyles"/> of the integer to parse.</param>
+        /// <param name="provider">The <see cref="IFormatProvider"/> to use when parsing the integer.</param>
+        /// <returns>The parsed <see cref="int"/>.</returns>
+        private static int ParseInt32(
+            ReadOnlySpan<char> span,
+            System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer,
+            IFormatProvider provider = null)
+        {
+#pragma warning disable IDE0022 // Use expression body for methods
+#if NETSTANDARD2_1 || NETCOREAPP2_1_OR_GREATER
+            return int.Parse(span, style, provider);
+#else
+            return int.Parse(span.ToString(), style, provider);
+#endif
+#pragma warning restore IDE0022 // Use expression body for methods
+        }
+
+        /// <summary>
+        /// Parses a hexadecimal string into a byte array without allocations.
+        /// Adapted from https://stackoverflow.com/a/9995303/871842
+        /// </summary>
+        /// <param name="hexString">The hexadecimal string to parse.</param>
+        /// <param name="outputBytes">The destination for the parsed bytes. Must be at least <paramref name="hexString"/>.Length / 2 bytes long.</param>
+        /// <returns>The number of bytes written to <paramref name="outputBytes"/>.</returns>
+        private static int HexStringToBytes(ReadOnlySpan<char> hexString, Span<byte> outputBytes)
+        {
+            if ((hexString.Length % 2) != 0)
+            {
+                throw new ArgumentException("Input string length must be a multiple of 2", nameof(hexString));
+            }
+
+            if ((outputBytes.Length * 2) < hexString.Length)
+            {
+                throw new ArgumentException("Output span must be at least half the length of the input string");
+            }
+
+            static int GetHexVal(char hexChar)
+            {
+                if (hexChar >= '0' && hexChar <= '9')
+                {
+                    return hexChar - '0';
+                }
+                else if (hexChar >= 'A' && hexChar <= 'F')
+                {
+                    return 10 + (hexChar - 'A');
+                }
+                else if (hexChar >= 'a' && hexChar <= 'f')
+                {
+                    return 10 + (hexChar - 'a');
+                }
+                else
+                {
+                    throw new ArgumentException($"Invalid hexadecimal value {hexChar}");
+                }
+            }
+
+            int inputByteCount = hexString.Length / 2;
+            for (int i = 0; i < inputByteCount; i++)
+            {
+                outputBytes[i] = (byte)((GetHexVal(hexString[i * 2]) << 4) + GetHexVal(hexString[(i * 2) + 1]));
+            }
+
+            return inputByteCount;
+        }
+
+        /// <summary>
+        /// Sets the <see cref="ExifProfile"/> in <paramref name="metadata"/> to <paramref name="newProfile"/>,
+        /// or copies exif tags if <paramref name="metadata"/> already contains an <see cref="ExifProfile"/>.
+        /// </summary>
+        /// <param name="metadata">The <see cref="ImageMetadata"/> to store the exif data in.</param>
+        /// <param name="newProfile">The <see cref="ExifProfile"/> to copy exif tags from.</param>
+        /// <param name="replaceExistingKeys">If <paramref name="metadata"/> already contains an <see cref="ExifProfile"/>,
+        /// controls whether existing exif tags in <paramref name="metadata"/> will be overwritten with any conflicting
+        /// tags from <paramref name="newProfile"/>.</param>
+        private void MergeOrSetExifProfile(ImageMetadata metadata, ExifProfile newProfile, bool replaceExistingKeys)
+        {
+            if (metadata.ExifProfile is null)
+            {
+                // No exif metadata was loaded yet, so just assign it
+                metadata.ExifProfile = newProfile;
+            }
+            else
+            {
+                // Try to merge existing keys with the ones from the new profile
+                foreach (IExifValue newKey in newProfile.Values)
+                {
+                    if (replaceExistingKeys || metadata.ExifProfile.GetValueInternal(newKey.Tag) is null)
+                    {
+                        metadata.ExifProfile.SetValueInternal(newKey.Tag, newKey.GetValue());
+                    }
+                }
+            }
         }
 
         /// <summary>

tests/ImageSharp.Tests/Formats/Png/PngMetadataTests.cs

@@ -289,5 +289,31 @@ private static void VerifyTextDataIsPresent(PngMetadata meta)
             Assert.Contains(meta.TextData, m => m.Keyword is "NoLang" && m.Value is "this text chunk is missing a language tag");
             Assert.Contains(meta.TextData, m => m.Keyword is "NoTranslatedKeyword" && m.Value is "dieser chunk hat kein übersetztes Schlüßelwort");
         }
+
+        [Theory]
+        [InlineData(TestImages.Png.Issue1875)]
+        public void Identify_ReadsLegacyExifData(string imagePath)
+        {
+            var testFile = TestFile.Create(imagePath);
+            using (var stream = new MemoryStream(testFile.Bytes, false))
+            {
+                IImageInfo imageInfo = Image.Identify(stream);
+                Assert.NotNull(imageInfo);
+                Assert.NotNull(imageInfo.Metadata.ExifProfile);
+                ExifProfile exif = imageInfo.Metadata.ExifProfile;
+
+                Assert.Equal(0, exif.InvalidTags.Count);
+                Assert.Equal(3, exif.Values.Count);
+
+                Assert.Equal(
+                    "A colorful tiling of blue, red, yellow, and green 4x4 pixel blocks.",
+                    exif.GetValue(ExifTag.ImageDescription).Value);
+                Assert.Equal(
+                    "Duplicated from basn3p02.png, then image metadata modified with exiv2",
+                    exif.GetValue(ExifTag.ImageHistory).Value);
+
+                Assert.Equal(42, (int)exif.GetValue(ExifTag.ImageNumber).Value);
+            }
+        }
     }
 }

tests/ImageSharp.Tests/TestImages.cs

@@ -117,6 +117,9 @@ public static class Png
             // Issue 1765: https://github.com/SixLabors/ImageSharp/issues/1765
             public const string Issue1765_Net6DeflateStreamRead = "Png/issues/Issue_1765_Net6DeflateStreamRead.png";
 
+            // Discussion 1875: https://github.com/SixLabors/ImageSharp/discussions/1875
+            public const string Issue1875 = "Png/raw-profile-type-exif.png";
+
             public static class Bad
             {
                 public const string MissingDataChunk = "Png/xdtn0g01.png";