Add .ico support to image diff

Extends the image-diff dispatch from #9 to Windows icon files. WPF's
`BitmapDecoder.Create` already routes ICO bytes to the built-in
`IconBitmapDecoder`, so most of the lift is detection + frame
selection:

- `ImageFormat` enum: add `Ico`.
- `ImageFormatDetector.DetectByExtension`: `.ico` ->
  `ImageFormat.Ico`.
- `ImageFormatDetector.Detect`: 4-byte magic `00 00 01 00` (icon
  type). CUR files (`00 00 02 00`) intentionally don't match; the
  `.cur` extension also stays unsupported.
- `WpfImageDecoder`: ICOs embed the same icon at multiple
  resolutions (16x16, 32x32, 48x48, 256x256). `Frames[0]` is
  typically the smallest and looks blurry fit-to-canvas, so the
  decoder now picks the largest frame by pixel area for ICO
  (tiebreak on bit depth so a 32bpp frame wins over a 4bpp frame at
  the same size). PNG / JPEG / BMP / GIF all keep `Frames[0]`.
- Tests: extension + magic-byte detection, CUR-shaped header
  correctly rejected, single-frame ICO round-trip, multi-resolution
  ICO with three frames (16/48/32) verifies that the 48x48 frame is
  picked regardless of frame order. Synthesises ICOs by hand
  (ICONDIR + ICONDIRENTRY + PNG payloads) since WPF ships no
  `IconBitmapEncoder`.
- CHANGELOG `[Unreleased]` + README features bullet: list ICO
  alongside PNG/JPEG/GIF/BMP and note the largest-resolution pick.

Verification: `dotnet build -c Release` -> 0 warnings;
`dotnet test` -> 1161 passed, 1 skipped.

Out of scope: `.cur` (cursor) support, multi-resolution selector
UI to let the user compare specific embedded sizes.

Closes #16

AI-Local-Session: bd41845c-9c2c-4d85-9096-da614c7d2662
AI-Cloud-Session: 6c878301-7f09-4cfd-80b6-5e34c328c217
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: geevensingh

CHANGELOG.md

@@ -60,18 +60,23 @@ body. Keep section headings exact and write notes in Markdown.
   language coloring, so changed-line signal isn't masked. Some
   pathological constructs may mis-color (notably TypeScript JSX
   attributes and Ruby heredocs); patch reports welcome.
-- Image diff for binary image blobs. PNG, JPEG, GIF, and BMP files
-  now render as an actual image-diff view instead of the generic
-  "Binary file - diff not displayed." placeholder. Three viewing
-  modes are exposed via toolbar radio buttons that replace the
-  text-only toggles when an image is shown: **Side-by-side** (two
-  fit-to-frame panes on a checkerboard background), **Swipe**
+- Image diff for binary image blobs. PNG, JPEG, GIF, BMP, and ICO
+  files now render as an actual image-diff view instead of the
+  generic "Binary file - diff not displayed." placeholder. Three
+  viewing modes are exposed via toolbar radio buttons that replace
+  the text-only toggles when an image is shown: **Side-by-side**
+  (two fit-to-frame panes on a checkerboard background), **Swipe**
   (overlay both images with a draggable divider — drag anywhere
   over the canvas), and **Onion-skin** (stack both images with an
-  opacity slider to blend between them). A header strip shows each
-  side's dimensions, byte size, and the byte delta (e.g.
-  `512 x 512 / 18.3 KB -> 1024 x 1024 / 64.1 KB  (+45.8 KB)`), with
-  an `(animated, first frame)` suffix when either side is a
+  opacity slider to blend between them). For added/deleted files
+  the single available image fills the full canvas and the mode
+  controls are hidden, since the three modes have no meaningful
+  semantics when one side is absent. ICO files render the largest
+  embedded resolution (a 256x256 frame is preferred over the 16x16
+  frame when both are present). A header strip shows each side's
+  dimensions, byte size, and the byte delta (e.g.
+  `512 x 512 / 18.3 KB -> 1024 x 1024 / 64.1 KB  (+45.8 KB)`),
+  with an `(animated, first frame)` suffix when either side is a
   multi-frame GIF. The size gate reuses the existing
   `LargeFileThresholdBytes` setting; over-threshold images still
   fall back to the binary placeholder. Format and mode state is

DiffViewer.Tests/Services/WpfImageDecoderTests.cs

@@ -137,6 +137,45 @@ public void Decode_SingleFrameGif_ReportsFrameCountOne()
         result.Metadata.FrameCount.Should().Be(1);
     }
 
+    [StaFact]
+    public void Decode_SingleFrameIco_RoundtripsAsIco()
+    {
+        var bytes = EncodeIco((32, 32, Colors.Purple));
+
+        var result = _decoder.Decode(bytes, "favicon.ico");
+
+        result.Image.Should().NotBeNull();
+        result.Error.Should().BeNull();
+        result.Metadata.Should().NotBeNull();
+        result.Metadata!.Format.Should().Be(ImageFormat.Ico);
+        result.Metadata.Width.Should().Be(32);
+        result.Metadata.Height.Should().Be(32);
+        result.Metadata.FrameCount.Should().Be(1);
+    }
+
+    [StaFact]
+    public void Decode_MultiResolutionIco_PicksLargestFrameByArea()
+    {
+        // Three frames at 16x16, 48x48, 32x32 (deliberately out of size
+        // order to verify the decoder picks by pixel area, not by frame
+        // index). The rendered bitmap should be the 48x48 one;
+        // FrameCount reports the total embedded count.
+        var bytes = EncodeIco(
+            (16, 16, Colors.Red),
+            (48, 48, Colors.Green),
+            (32, 32, Colors.Blue));
+
+        var result = _decoder.Decode(bytes, "favicon.ico");
+
+        result.Image.Should().NotBeNull();
+        result.Error.Should().BeNull();
+        result.Metadata.Should().NotBeNull();
+        result.Metadata!.Format.Should().Be(ImageFormat.Ico);
+        result.Metadata.Width.Should().Be(48);
+        result.Metadata.Height.Should().Be(48);
+        result.Metadata.FrameCount.Should().Be(3);
+    }
+
     private static byte[] EncodeSolidPng(int width, int height)
     {
         var frame = MakeBgra32Frame(width, height, Colors.Red);
@@ -181,6 +220,59 @@ private static byte[] EncodeMultiFrameGif(int width, int height, int frames)
         return stream.ToArray();
     }
 
+    // Build a minimal ICO containing the given frames, each embedded as
+    // a PNG payload (Vista+ ICO format). We synthesise the ICONDIR +
+    // ICONDIRENTRY bytes by hand because WPF ships an IconBitmapDecoder
+    // but no IconBitmapEncoder, so a roundtrip via WPF isn't possible.
+    private static byte[] EncodeIco(params (int width, int height, Color color)[] frames)
+    {
+        var pngBlobs = frames
+            .Select(f => EncodeSolidPng(f.width, f.height, f.color))
+            .ToArray();
+
+        using var stream = new MemoryStream();
+        using var writer = new BinaryWriter(stream);
+
+        // ICONDIR (6 bytes)
+        writer.Write((ushort)0);              // idReserved
+        writer.Write((ushort)1);              // idType (1 = icon)
+        writer.Write((ushort)pngBlobs.Length); // idCount
+
+        // Each ICONDIRENTRY is 16 bytes; image data follows after all
+        // entries so initial offset = 6 + 16 * N.
+        var offset = 6 + 16 * pngBlobs.Length;
+        for (var i = 0; i < pngBlobs.Length; i++)
+        {
+            var (w, h, _) = frames[i];
+            writer.Write((byte)(w == 256 ? 0 : w)); // bWidth (0 means 256)
+            writer.Write((byte)(h == 256 ? 0 : h)); // bHeight
+            writer.Write((byte)0);                  // bColorCount (0 for >=8bpp)
+            writer.Write((byte)0);                  // bReserved
+            writer.Write((ushort)1);                // wPlanes
+            writer.Write((ushort)32);               // wBitCount
+            writer.Write((uint)pngBlobs[i].Length); // dwBytesInRes
+            writer.Write((uint)offset);             // dwImageOffset
+            offset += pngBlobs[i].Length;
+        }
+
+        foreach (var blob in pngBlobs)
+        {
+            writer.Write(blob);
+        }
+
+        return stream.ToArray();
+    }
+
+    private static byte[] EncodeSolidPng(int width, int height, Color color)
+    {
+        var frame = MakeBgra32Frame(width, height, color);
+        var encoder = new PngBitmapEncoder();
+        encoder.Frames.Add(BitmapFrame.Create(frame));
+        using var stream = new MemoryStream();
+        encoder.Save(stream);
+        return stream.ToArray();
+    }
+
     private static BitmapSource MakeBgra32Frame(int width, int height, Color color)
     {
         var stride = width * 4;

DiffViewer.Tests/Utility/ImageFormatDetectorTests.cs

@@ -16,6 +16,8 @@ public class ImageFormatDetectorTests
     private static readonly byte[] Gif87aSignature = "GIF87a"u8.ToArray();
     private static readonly byte[] Gif89aSignature = "GIF89a"u8.ToArray();
     private static readonly byte[] BmpSignature = "BM"u8.ToArray();
+    // ICO header: 00 00 (reserved) + 01 00 (type=icon, little-endian).
+    private static readonly byte[] IcoSignature = { 0x00, 0x00, 0x01, 0x00 };
 
     [Fact]
     public void Detect_PngMagic_ReturnsPng()
@@ -37,6 +39,19 @@ public void Detect_Gif89aMagic_ReturnsGif()
     public void Detect_BmpMagic_ReturnsBmp()
         => ImageFormatDetector.Detect(BmpSignature, "drawing.bmp").Should().Be(ImageFormat.Bmp);
 
+    [Fact]
+    public void Detect_IcoMagic_ReturnsIco()
+        => ImageFormatDetector.Detect(IcoSignature, "favicon.ico").Should().Be(ImageFormat.Ico);
+
+    [Fact]
+    public void Detect_IcoMagicWrongType_DoesNotMatch()
+    {
+        // CUR files use 00 00 02 00 (type=cursor). They are out of scope
+        // in v1, so a CUR-shaped header must not classify as Ico.
+        var curHeader = new byte[] { 0x00, 0x00, 0x02, 0x00 };
+        ImageFormatDetector.Detect(curHeader, "pointer.cur").Should().Be(ImageFormat.NotAnImage);
+    }
+
     [Fact]
     public void Detect_MagicBytesWinOverExtension_PngLabelledAsJpg()
     {
@@ -88,6 +103,7 @@ public void Detect_UnrecognizedBytesButImageExtension_FallsBackToExtension()
     [InlineData("photo.Png", ImageFormat.Png)]
     [InlineData("anim.GIF", ImageFormat.Gif)]
     [InlineData("draw.BMP", ImageFormat.Bmp)]
+    [InlineData("favicon.ICO", ImageFormat.Ico)]
     public void DetectByExtension_IsCaseInsensitive(string path, ImageFormat expected)
         => ImageFormatDetector.DetectByExtension(path).Should().Be(expected);
 
@@ -97,6 +113,7 @@ public void DetectByExtension_IsCaseInsensitive(string path, ImageFormat expecte
     [InlineData(".jpeg", ImageFormat.Jpeg)]
     [InlineData(".gif", ImageFormat.Gif)]
     [InlineData(".bmp", ImageFormat.Bmp)]
+    [InlineData(".ico", ImageFormat.Ico)]
     public void DetectByExtension_BareExtensionDotPrefix_Resolves(string path, ImageFormat expected)
         => ImageFormatDetector.DetectByExtension(path).Should().Be(expected);
 
@@ -108,6 +125,7 @@ public void DetectByExtension_BareExtensionDotPrefix_Resolves(string path, Image
     [InlineData(".svg")]
     [InlineData(".webp")]
     [InlineData(".tiff")]
+    [InlineData(".cur")]
     public void DetectByExtension_UnsupportedOrMissing_ReturnsNotAnImage(string? path)
         => ImageFormatDetector.DetectByExtension(path).Should().Be(ImageFormat.NotAnImage);
 

DiffViewer/Models/ImageFormat.cs

@@ -18,4 +18,5 @@ public enum ImageFormat
     Jpeg,
     Gif,
     Bmp,
+    Ico,
 }

DiffViewer/Services/WpfImageDecoder.cs

@@ -60,7 +60,15 @@ public ImageDecodeResult Decode(byte[] bytes, string? path)
                     Error: "Decoder reported zero frames.");
             }
 
-            var frame = decoder.Frames[0];
+            // ICOs embed the same icon at multiple resolutions (16x16,
+            // 32x32, 48x48, 256x256). Frames[0] is typically the
+            // smallest and looks blurry when fit-to-canvas, so pick the
+            // largest frame by area for icons. For animated GIFs and
+            // single-frame formats Frames[0] is correct, so the
+            // selector is gated on format.
+            BitmapFrame frame = format == ImageFormat.Ico
+                ? PickLargestFrame(decoder.Frames)
+                : decoder.Frames[0];
             // Freeze so the bitmap can cross threads. Required because
             // the production decode runs on a Task.Run worker and the
             // bitmap is handed off to the UI thread for binding.
@@ -89,4 +97,28 @@ or InvalidOperationException
                 Error: $"{ex.GetType().Name}: {ex.Message}");
         }
     }
+
+    // Picks the largest frame by pixel area, with bit depth as a
+    // tiebreaker so a 256x256 32bpp icon beats a 256x256 4bpp icon.
+    // WIC exposes Format.BitsPerPixel; for unknown formats it returns
+    // 0 which sorts last, also fine.
+    private static BitmapFrame PickLargestFrame(IReadOnlyList<BitmapFrame> frames)
+    {
+        BitmapFrame best = frames[0];
+        long bestArea = (long)best.PixelWidth * best.PixelHeight;
+        int bestDepth = best.Format.BitsPerPixel;
+        for (int i = 1; i < frames.Count; i++)
+        {
+            var f = frames[i];
+            long area = (long)f.PixelWidth * f.PixelHeight;
+            int depth = f.Format.BitsPerPixel;
+            if (area > bestArea || (area == bestArea && depth > bestDepth))
+            {
+                best = f;
+                bestArea = area;
+                bestDepth = depth;
+            }
+        }
+        return best;
+    }
 }

DiffViewer/Utility/ImageFormatDetector.cs

@@ -36,11 +36,21 @@ internal static class ImageFormatDetector
     private static ReadOnlySpan<byte> Gif87aSignature => "GIF87a"u8;
     private static ReadOnlySpan<byte> Gif89aSignature => "GIF89a"u8;
 
-    // BMP — 2-byte "BM" header. Weakest signature of the four; we still
-    // accept it on bytes alone because no other common format starts with
-    // those two ASCII letters.
+    // BMP — 2-byte "BM" header. Weakest of the magic-byte signatures;
+    // we still accept it on bytes alone because no other common format
+    // starts with those two ASCII letters.
     private static ReadOnlySpan<byte> BmpSignature => "BM"u8;
 
+    // ICO — 4-byte header: 00 00 (reserved) + 01 00 (image type = icon,
+    // little-endian). CUR files use 02 00 in the type field and are not
+    // supported. The signature is short and not particularly distinctive,
+    // but combined with the extension fallback in DetectByExtension this
+    // is enough for practical use.
+    private static ReadOnlySpan<byte> IcoSignature => new byte[]
+    {
+        0x00, 0x00, 0x01, 0x00,
+    };
+
     /// <summary>
     /// Identify the image format of <paramref name="bytes"/>. Falls back
     /// to <paramref name="path"/>'s extension when the byte signature is
@@ -54,6 +64,7 @@ public static ImageFormat Detect(ReadOnlySpan<byte> bytes, string? path)
         if (StartsWith(bytes, Gif87aSignature) ||
             StartsWith(bytes, Gif89aSignature)) return ImageFormat.Gif;
         if (StartsWith(bytes, BmpSignature)) return ImageFormat.Bmp;
+        if (StartsWith(bytes, IcoSignature)) return ImageFormat.Ico;
 
         return path is null ? ImageFormat.NotAnImage : DetectByExtension(path);
     }
@@ -77,6 +88,7 @@ public static ImageFormat DetectByExtension(string? path)
             ".jpeg" => ImageFormat.Jpeg,
             ".gif" => ImageFormat.Gif,
             ".bmp" => ImageFormat.Bmp,
+            ".ico" => ImageFormat.Ico,
             _ => ImageFormat.NotAnImage,
         };
     }

README.md

@@ -31,13 +31,15 @@ individual hunks.
   hunk from the working tree" confirmation (suppressible).
 - Live updates when the working tree changes (Ctrl+L; automatically
   disabled for commit-vs-commit comparisons).
-- **Image diff for PNG, JPEG, GIF, and BMP** files. Binary image
-  blobs render as an actual image diff (instead of the generic
+- **Image diff for PNG, JPEG, GIF, BMP, and ICO** files. Binary
+  image blobs render as an actual image diff (instead of the generic
   binary placeholder) with three modes: side-by-side, swipe (drag
-  anywhere over the canvas), and onion-skin. A header strip shows
-  each side's dimensions, byte size, and the byte delta. Reuses
-  the existing large-file threshold; over-threshold images fall
-  back to the binary placeholder.
+  anywhere over the canvas), and onion-skin. Added/deleted images
+  render full-canvas with the mode controls hidden. ICO files
+  render the largest embedded resolution. A header strip shows each
+  side's dimensions, byte size, and the byte delta. Reuses the
+  existing large-file threshold; over-threshold images fall back to
+  the binary placeholder.
 - Persistent settings and a **recent launch contexts** dropdown (up to 10
   entries) so jumping back to "working tree of repo X" or "two commits in
   repo Y" is one click.