[Peek]Adds QOI file support (#29919)

* Adds QOI support to Peek

* Reduce allocations on QoiImage

* Add to QOI to Peek's NOTICE as well.

* Ensure file stream is closed after reading QOI

src/common/FilePreviewCommon/FilePreviewCommon.csproj

@@ -4,12 +4,15 @@
 
   <PropertyGroup>
     <TargetFramework>net8.0-windows</TargetFramework>
-	<RuntimeIdentifiers>win-x64;win-arm64</RuntimeIdentifiers>
+    <RuntimeIdentifiers>win-x64;win-arm64</RuntimeIdentifiers>
     <Version>$(Version).0</Version>
     <Authors>Microsoft Corporation</Authors>
     <Product>PowerToys</Product>
     <Description>PowerToys FilePreviewCommon</Description>
     <AssemblyName>PowerToys.FilePreviewCommon</AssemblyName>
+    <UseWindowsForms>true</UseWindowsForms>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
@@ -32,7 +35,7 @@
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
     <Content Include="Assets\Monaco\monacoSRC\**">
-        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Content>
     <None Update="Assets\Monaco\monaco_languages.json">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>

src/common/FilePreviewCommon/Formatters/XmlFormatter.cs

@@ -26,7 +26,7 @@ namespace Microsoft.PowerToys.FilePreviewCommon.Monaco.Formatters
             var stringBuilder = new StringBuilder();
             var xmlWriterSettings = new XmlWriterSettings()
             {
-                OmitXmlDeclaration = xmlDocument.FirstChild.NodeType != XmlNodeType.XmlDeclaration,
+                OmitXmlDeclaration = xmlDocument.FirstChild?.NodeType != XmlNodeType.XmlDeclaration,
                 Indent = true,
             };
 

src/common/FilePreviewCommon/GcodeHelper.cs

@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace Microsoft.PowerToys.FilePreviewCommon
+{
+    /// <summary>
+    /// Gcode file helper class.
+    /// </summary>
+    public static class GcodeHelper
+    {
+        /// <summary>
+        /// Gets any thumbnails found in a gcode file.
+        /// </summary>
+        /// <param name="reader">The <see cref="TextReader"/> instance to the gcode file.</param>
+        /// <returns>The thumbnails found in a gcode file.</returns>
+        public static IEnumerable<GcodeThumbnail> GetThumbnails(TextReader reader)
+        {
+            string? line;
+            var format = GcodeThumbnailFormat.Unknown;
+            StringBuilder? capturedText = null;
+
+            while ((line = reader.ReadLine()) != null)
+            {
+                if (line.StartsWith("; thumbnail", StringComparison.InvariantCulture))
+                {
+                    var parts = line[11..].Split(" ");
+
+                    switch (parts[1])
+                    {
+                        case "begin":
+                            format = parts[0].ToUpperInvariant() switch
+                            {
+                                "" => GcodeThumbnailFormat.PNG,
+                                "_JPG" => GcodeThumbnailFormat.JPG,
+                                "_QOI" => GcodeThumbnailFormat.QOI,
+                                _ => GcodeThumbnailFormat.Unknown,
+                            };
+                            capturedText = new StringBuilder();
+
+                            break;
+
+                        case "end":
+                            if (capturedText != null)
+                            {
+                                yield return new GcodeThumbnail(format, capturedText.ToString());
+
+                                capturedText = null;
+                            }
+
+                            break;
+                    }
+                }
+                else
+                {
+                    capturedText?.Append(line[2..]);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the best thumbnail available in a gcode file.
+        /// </summary>
+        /// <param name="reader">The <see cref="TextReader"/> instance to the gcode file.</param>
+        /// <returns>The best thumbnail available in the gcode file.</returns>
+        public static GcodeThumbnail? GetBestThumbnail(TextReader reader)
+        {
+            return GetThumbnails(reader)
+                .Where(x => x.Format != GcodeThumbnailFormat.Unknown)
+                .OrderByDescending(x => (int)x.Format)
+                .ThenByDescending(x => x.Data.Length)
+                .FirstOrDefault();
+        }
+    }
+}

src/common/FilePreviewCommon/GcodeThumbnail.cs

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Drawing;
+using System.IO;
+
+namespace Microsoft.PowerToys.FilePreviewCommon
+{
+    /// <summary>
+    /// Represents a gcode thumbnail.
+    /// </summary>
+    public class GcodeThumbnail
+    {
+        /// <summary>
+        /// Gets the gcode thumbnail image format.
+        /// </summary>
+        public GcodeThumbnailFormat Format { get; }
+
+        /// <summary>
+        /// Gets the gcode thumbnail image data in base64.
+        /// </summary>
+        public string Data { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GcodeThumbnail"/> class.
+        /// </summary>
+        /// <param name="format">The gcode thumbnail image format.</param>
+        /// <param name="data">The gcode thumbnail image data in base64.</param>
+        public GcodeThumbnail(GcodeThumbnailFormat format, string data)
+        {
+            Format = format;
+            Data = data;
+        }
+
+        /// <summary>
+        /// Gets a <see cref="Bitmap"/> representing this thumbnail.
+        /// </summary>
+        /// <returns>A <see cref="Bitmap"/> representing this thumbnail.</returns>
+        public Bitmap? GetBitmap()
+        {
+            switch (Format)
+            {
+                case GcodeThumbnailFormat.JPG:
+                case GcodeThumbnailFormat.PNG:
+                    return BitmapFromBase64String();
+
+                case GcodeThumbnailFormat.QOI:
+                    return BitmapFromQoiBase64String();
+
+                default:
+                    return null;
+            }
+        }
+
+        private Bitmap BitmapFromBase64String()
+        {
+            var bitmapBytes = Convert.FromBase64String(Data);
+
+            return new Bitmap(new MemoryStream(bitmapBytes));
+        }
+
+        private Bitmap BitmapFromQoiBase64String()
+        {
+            var bitmapBytes = Convert.FromBase64String(Data);
+
+            return QoiImage.FromStream(new MemoryStream(bitmapBytes));
+        }
+    }
+}

src/common/FilePreviewCommon/GcodeThumbnailFormat.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.PowerToys.FilePreviewCommon
+{
+    /// <summary>
+    /// The gcode thumbnail image format.
+    /// </summary>
+    public enum GcodeThumbnailFormat
+    {
+        /// <summary>
+        /// Unknown image format.
+        /// </summary>
+        Unknown,
+
+        /// <summary>
+        /// JPG image format.
+        /// </summary>
+        JPG,
+
+        /// <summary>
+        /// QOI image format.
+        /// </summary>
+        QOI,
+
+        /// <summary>
+        /// PNG image format.
+        /// </summary>
+        PNG,
+    }
+}

src/common/FilePreviewCommon/MarkdownHelper.cs

@@ -30,7 +30,7 @@ namespace Microsoft.PowerToys.FilePreviewCommon
 
             // Extension to modify markdown AST.
             HTMLParsingExtension extension = new HTMLParsingExtension(imagesBlockedCallBack);
-            extension.FilePath = Path.GetDirectoryName(filePath);
+            extension.FilePath = Path.GetDirectoryName(filePath) ?? string.Empty;
 
             // if you have a string with double space, some people view it as a new line.
             // while this is against spec, even GH supports this. Technically looks like GH just trims whitespace

src/common/FilePreviewCommon/MonacoHelper.cs

@@ -28,12 +28,12 @@ namespace Microsoft.PowerToys.FilePreviewCommon
             new XmlFormatter(),
         }.AsReadOnly();
 
-        private static string _monacoDirectory;
+        private static string? _monacoDirectory;
 
         public static string GetRuntimeMonacoDirectory()
         {
             string codeBase = Assembly.GetExecutingAssembly().Location;
-            string path = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(codeBase), "Assets", "Monaco"));
+            string path = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(codeBase) ?? string.Empty, "Assets", "Monaco"));
             if (Path.Exists(path))
             {
                 return path;
@@ -41,7 +41,7 @@ namespace Microsoft.PowerToys.FilePreviewCommon
             else
             {
                 // We're likely in WinUI3Apps directory and need to go back to the base directory.
-                return Path.GetFullPath(Path.Combine(Path.GetDirectoryName(codeBase), "..", "Assets", "Monaco"));
+                return Path.GetFullPath(Path.Combine(Path.GetDirectoryName(codeBase) ?? string.Empty, "..", "Assets", "Monaco"));
             }
         }
 

src/common/FilePreviewCommon/QoiImage.cs

@@ -0,0 +1,177 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Buffers.Binary;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Text;
+
+//// Based on https://github.com/phoboslab/qoi/blob/master/qoi.h
+
+namespace Microsoft.PowerToys.FilePreviewCommon
+{
+    /// <summary>
+    /// QOI Image helper.
+    /// </summary>
+    public static class QoiImage
+    {
+#pragma warning disable SA1310 // Field names should not contain underscore
+        private const byte QOI_OP_INDEX = 0x00; // 00xxxxxx
+        private const byte QOI_OP_DIFF = 0x40;  // 01xxxxxx
+        private const byte QOI_OP_LUMA = 0x80;  // 10xxxxxx
+        private const byte QOI_OP_RUN = 0xc0;   // 11xxxxxx
+        private const byte QOI_OP_RGB = 0xfe;   // 11111110
+        private const byte QOI_OP_RGBA = 0xff;  // 11111111
+
+        private const byte QOI_MASK_2 = 0xc0;   // 11000000
+
+        private const int QOI_MAGIC = 'q' << 24 | 'o' << 16 | 'i' << 8 | 'f';
+        private const int QOI_HEADER_SIZE = 14;
+
+        private const uint QOI_PIXELS_MAX = 400000000;
+
+        private const byte QOI_PADDING_LENGTH = 8;
+#pragma warning restore SA1310 // Field names should not contain underscore
+
+        private record struct QoiPixel(byte R, byte G, byte B, byte A)
+        {
+            public readonly int GetColorHash() => (R * 3) + (G * 5) + (B * 7) + (A * 11);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="Bitmap"/> from the specified QOI data stream.
+        /// </summary>
+        /// <param name="stream">A <see cref="Stream"/> that contains the QOI data.</param>
+        /// <returns>The <see cref="Bitmap"/> this method creates.</returns>
+        /// <exception cref="ArgumentException">The stream does not have a valid QOI image format.</exception>
+        public static Bitmap FromStream(Stream stream)
+        {
+            var fileSize = stream.Length;
+
+            if (fileSize < QOI_HEADER_SIZE + QOI_PADDING_LENGTH)
+            {
+                throw new ArgumentException("Not enough data for a QOI file");
+            }
+
+            Bitmap? bitmap = null;
+
+            try
+            {
+                using var reader = new BinaryReader(stream, Encoding.UTF8, true);
+
+                var headerMagic = ReadUInt32BigEndian(reader);
+
+                if (headerMagic != QOI_MAGIC)
+                {
+                    throw new ArgumentException("Invalid QOI file header");
+                }
+
+                var width = ReadUInt32BigEndian(reader);
+                var height = ReadUInt32BigEndian(reader);
+                var channels = reader.ReadByte();
+                var colorSpace = reader.ReadByte();
+
+                if (width == 0 || height == 0 || channels < 3 || channels > 4 || colorSpace > 1 || height >= QOI_PIXELS_MAX / width)
+                {
+                    throw new ArgumentException("Invalid QOI file data");
+                }
+
+                var pixelFormat = channels == 4 ? PixelFormat.Format32bppArgb : PixelFormat.Format24bppRgb;
+
+                bitmap = new Bitmap((int)width, (int)height, pixelFormat);
+
+                var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.WriteOnly, pixelFormat);
+                var dataLength = bitmapData.Height * bitmapData.Stride;
+
+                var index = new QoiPixel[64];
+                var pixel = new QoiPixel(0, 0, 0, 255);
+
+                var run = 0;
+                var chunksLen = fileSize - QOI_PADDING_LENGTH;
+
+                for (var dataIndex = 0; dataIndex < dataLength; dataIndex += channels)
+                {
+                    if (run > 0)
+                    {
+                        run--;
+                    }
+                    else if (stream.Position < chunksLen)
+                    {
+                        var b1 = reader.ReadByte();
+
+                        if (b1 == QOI_OP_RGB)
+                        {
+                            pixel.R = reader.ReadByte();
+                            pixel.G = reader.ReadByte();
+                            pixel.B = reader.ReadByte();
+                        }
+                        else if (b1 == QOI_OP_RGBA)
+                        {
+                            pixel.R = reader.ReadByte();
+                            pixel.G = reader.ReadByte();
+                            pixel.B = reader.ReadByte();
+                            pixel.A = reader.ReadByte();
+                        }
+                        else if ((b1 & QOI_MASK_2) == QOI_OP_INDEX)
+                        {
+                            pixel = index[b1];
+                        }
+                        else if ((b1 & QOI_MASK_2) == QOI_OP_DIFF)
+                        {
+                            pixel.R += (byte)(((b1 >> 4) & 0x03) - 2);
+                            pixel.G += (byte)(((b1 >> 2) & 0x03) - 2);
+                            pixel.B += (byte)((b1 & 0x03) - 2);
+                        }
+                        else if ((b1 & QOI_MASK_2) == QOI_OP_LUMA)
+                        {
+                            var b2 = reader.ReadByte();
+                            var vg = (b1 & 0x3f) - 32;
+                            pixel.R += (byte)(vg - 8 + ((b2 >> 4) & 0x0f));
+                            pixel.G += (byte)vg;
+                            pixel.B += (byte)(vg - 8 + (b2 & 0x0f));
+                        }
+                        else if ((b1 & QOI_MASK_2) == QOI_OP_RUN)
+                        {
+                            run = b1 & 0x3f;
+                        }
+
+                        index[pixel.GetColorHash() % 64] = pixel;
+                    }
+
+                    unsafe
+                    {
+                        var bitmapPixel = (byte*)bitmapData.Scan0 + dataIndex;
+
+                        bitmapPixel[0] = pixel.B;
+                        bitmapPixel[1] = pixel.G;
+                        bitmapPixel[2] = pixel.R;
+                        if (channels == 4)
+                        {
+                            bitmapPixel[3] = pixel.A;
+                        }
+                    }
+                }
+
+                bitmap.UnlockBits(bitmapData);
+
+                return bitmap;
+            }
+            catch
+            {
+                bitmap?.Dispose();
+
+                throw;
+            }
+        }
+
+        private static uint ReadUInt32BigEndian(BinaryReader reader)
+        {
+            var buffer = reader.ReadBytes(4);
+
+            return BinaryPrimitives.ReadUInt32BigEndian(buffer);
+        }
+    }
+}