Improve ImageHeader and guessing file type. Move img unit testing to be async

Author: onizet

src/Html2OpenXml/HtmlConverter.cs

@@ -15,6 +15,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using AngleSharp;
+using AngleSharp.Html.Dom;
 using DocumentFormat.OpenXml;
 using DocumentFormat.OpenXml.Packaging;
 using DocumentFormat.OpenXml.Wordprocessing;
@@ -277,18 +278,18 @@ private async Task<IEnumerable<OpenXmlCompositeElement>> ParseCoreAsync(string h
     /// <summary>
     /// Walk through all the <c>img</c> tags and preload all the remote images.
     /// </summary>
-    private async Task PreloadImages(AngleSharp.Dom.IDocument htmlDocument,
+    private static async Task PreloadImages(AngleSharp.Dom.IDocument htmlDocument,
         IImageLoader imageLoader, ParallelOptions parallelOptions)
     {
         var imageUris = htmlDocument.QuerySelectorAll("img[src]")
-            .Cast<AngleSharp.Html.Dom.IHtmlImageElement>()
+            .Cast<IHtmlImageElement>()
             .Where(e => AngleSharpExtensions.TryParseUrl(e.GetAttribute("src"), UriKind.RelativeOrAbsolute, out var _))
             .Select(e => e.GetAttribute("src")!);
         if (!imageUris.Any())
             return;
 
         await imageUris.ForEachAsync(
-            async (img, cts) => await imageLoader.Download(img, cts).ConfigureAwait(false),
+            async (img, cts) => await imageLoader.Download(img, cts),
             parallelOptions).ConfigureAwait(false);
     }
 

src/Html2OpenXml/IO/ImageHeader.cs

@@ -58,12 +58,10 @@ public enum FileType { Unrecognized, Bitmap, Gif, Png, Jpeg, Emf, Xml }
     /// <returns>Returns true if the detection was successful.</returns>
     public static bool TryDetectFileType(Stream stream, out FileType type)
     {
-        using (SequentialBinaryReader reader = new SequentialBinaryReader(stream, leaveOpen: true))
-        {
-            type = DetectFileType(reader);
-            stream.Seek(0L, SeekOrigin.Begin);
-            return type != FileType.Unrecognized;
-        }
+        using var reader = new SequentialBinaryReader(stream, leaveOpen: true);
+        type = DetectFileType(reader);
+        stream.Seek(0L, SeekOrigin.Begin);
+        return type != FileType.Unrecognized;
     }
 
     /// <summary>
@@ -74,21 +72,19 @@ public static bool TryDetectFileType(Stream stream, out FileType type)
     /// <exception cref="ArgumentException">The image was of an unrecognised format.</exception>
     public static Size GetDimensions(Stream stream)
     {
-        using (SequentialBinaryReader reader = new SequentialBinaryReader(stream, leaveOpen: true))
+        using var reader = new SequentialBinaryReader(stream, leaveOpen: true);
+        FileType type = DetectFileType(reader);
+        stream.Seek(0L, SeekOrigin.Begin);
+        return type switch
         {
-            FileType type = DetectFileType (reader);
-            stream.Seek(0L, SeekOrigin.Begin);
-            switch (type)
-            {
-                case FileType.Bitmap: return DecodeBitmap(reader);
-                case FileType.Gif: return DecodeGif(reader);
-                case FileType.Jpeg: return DecodeJfif(reader);
-                case FileType.Png: return DecodePng(reader);
-                case FileType.Emf: return DecodeEmf(reader);
-                case FileType.Xml: return DecodeXml(stream);
-                default: return Size.Empty;
-            }
-        }
+            FileType.Bitmap => DecodeBitmap(reader),
+            FileType.Gif => DecodeGif(reader),
+            FileType.Jpeg => DecodeJfif(reader),
+            FileType.Png => DecodePng(reader),
+            FileType.Emf => DecodeEmf(reader),
+            FileType.Xml => DecodeXml(stream),
+            _ => Size.Empty,
+        };
     }
 
     /// <summary>
@@ -123,36 +119,19 @@ public static Size KeepAspectRatio(Size actualSize, Size preferredSize)
     private static FileType DetectFileType (SequentialBinaryReader reader)
     {
         byte[] magicBytes = new byte[MaxMagicBytesLength];
-        for (int i = 0; i < MaxMagicBytesLength; i += 1)
-        {
-            magicBytes[i] = reader.ReadByte();
-            foreach (var kvPair in imageFormatDecoders)
-            {
-                if (StartsWith(magicBytes, kvPair.Key))
-                {
-                    return kvPair.Value;
-                }
-            }
-        }
-
-        return FileType.Unrecognized;
-    }
+        reader.Read(magicBytes, 0, MaxMagicBytesLength);
 
-    /// <summary>
-    /// Determines whether the beginning of this byte array instance matches the specified byte array.
-    /// </summary>
-    /// <returns>Returns true if the first array starts with the bytes of the second array.</returns>
-    private static bool StartsWith(byte[] thisBytes, byte[] thatBytes)
-    {
-        for (int i = 0; i < thatBytes.Length; i += 1)
+        var headerSpan = magicBytes.AsSpan();
+        foreach (var kvPair in imageFormatDecoders)
         {
-            if (thisBytes[i] != thatBytes[i])
+            // Determines whether the beginning of this array matches s known header.
+            if (headerSpan.StartsWith(kvPair.Key))
             {
-                return false;
+                return kvPair.Value;
             }
         }
 
-        return true;
+        return FileType.Unrecognized;
     }
 
     private static Size DecodeBitmap(SequentialBinaryReader reader)
@@ -220,16 +199,16 @@ private static Size DecodeJfif(SequentialBinaryReader reader)
                 return Size.Empty;
 
             // next 2-bytes are <segment-size>: [high-byte] [low-byte]
-            var segmentLength = (int)reader.ReadUInt16();
+            int segmentLength = reader.ReadUInt16();
 
             // segment length includes size bytes, so subtract two
             segmentLength -= 2;
 
             if (segmentType == 0xC0 || segmentType == 0xC2)
             {
                 reader.ReadByte(); // bits/sample, usually 8
-                int height = (int) reader.ReadUInt16();
-                int width = (int) reader.ReadUInt16();
+                int height = reader.ReadUInt16();
+                int width = reader.ReadUInt16();
                 return new Size(width, height);
             }
             else

test/HtmlToOpenXml.Tests/ImgTests.cs

@@ -16,12 +16,16 @@ namespace HtmlToOpenXml.Tests
     public class ImgTests : HtmlConverterTestBase
     {
         [TestCase("https://www.w3schools.com/tags/smiley.gif", "image/gif")]
-        [TestCase("https://dev.w3.org/SVG/tools/svgweb/samples/svg-files/helloworld.svg", "image/svg+xml")]
-        public void AbsoluteUri_ReturnsDrawing_WithDownloadedData(string imageUri, string contentType)
+        [TestCase("https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Introduction/dino.svg", "image/svg+xml")]
+        public async Task AbsoluteUri_ReturnsDrawing_WithDownloadedData(string imageUri, string contentType)
         {
-            var elements = converter.Parse(@$"<img src='{imageUri}' alt='Smiley face' width='42' height='42'>");
-            Assert.That(elements, Has.Count.EqualTo(1));
-            var (_, imagePart) = AssertIsImg(mainPart, elements[0]);
+            await converter.ParseBody(
+                @$"<img src='{imageUri}' alt='Smiley face' width='42' height='42'>",
+                TestContext.CurrentContext.CancellationToken);
+
+            var paragraphs = mainPart.Document.Body!.Elements<Paragraph>();
+            Assert.That(paragraphs.Count(), Is.EqualTo(1));
+            var (_, imagePart) = AssertIsImg(mainPart, paragraphs.First());
             Assert.That(imagePart.ContentType, Is.EqualTo(contentType));
         }
 
@@ -128,7 +132,8 @@ public async Task RemoteImage_WithBaseUri_ShouldSucceed()
             converter = new HtmlConverter(mainPart, new IO.DefaultWebRequest() { 
                 BaseImageUrl = new Uri("http://github.com/onizet/html2openxml")
             });
-            var elements = await converter.ParseAsync($"<img src='/blob/dev/icon.png'>");
+            var elements = await converter.ParseAsync($"<img src='/blob/dev/icon.png'>",
+                TestContext.CurrentContext.CancellationToken);
             Assert.That(elements, Is.Not.Empty);
             AssertIsImg(mainPart, elements.First());
         }