From 3431ad321ed48e440712b60fe1ca227708e3ee58 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Tue, 7 May 2019 19:58:14 +0200
Subject: [PATCH 1/8] Add support for encoding 8-bit bitmaps

---
 src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs |   7 +-
 src/ImageSharp/Formats/Bmp/BmpEncoder.cs      |   1 -
 src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs  |  60 +++++++++++++++++-
 .../Formats/Bmp/IBmpEncoderOptions.cs         |   1 -
 .../Quantization/QuantizedFrame{TPixel}.cs    |   2 +-
 .../Formats/Bmp/BmpEncoderTests.cs            |   9 ++-
 tests/ImageSharp.Tests/TestImages.cs          |   1 +
 .../TestUtilities/PixelTypes.cs               |   2 +
 tests/Images/Input/Bmp/pal8gs.bmp             | Bin 0 -> 9254 bytes
 9 files changed, 76 insertions(+), 7 deletions(-)
 create mode 100644 tests/Images/Input/Bmp/pal8gs.bmp

diff --git a/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs b/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs
index 38f5c1d662..6e1145beb7 100644
--- a/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs
@@ -4,10 +4,15 @@
 namespace SixLabors.ImageSharp.Formats.Bmp
 {
     /// <summary>
-    /// Enumerates the available bits per pixel for bitmap.
+    /// Enumerates the available bits per pixel the bitmap encoder supports.
     /// </summary>
     public enum BmpBitsPerPixel : short
     {
+        /// <summary>
+        /// 8 bits per pixel. Each pixel consists of 1 byte.
+        /// </summary>
+        Pixel8 = 8,
+
         /// <summary>
         /// 16 bits per pixel. Each pixel consists of 2 bytes.
         /// </summary>
diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoder.cs b/src/ImageSharp/Formats/Bmp/BmpEncoder.cs
index 4efdedb349..f3eb9282ce 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoder.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoder.cs
@@ -10,7 +10,6 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     /// <summary>
     /// Image encoder for writing an image to a stream as a Windows bitmap.
     /// </summary>
-    /// <remarks>The encoder can currently only write 24-bit rgb images to streams.</remarks>
     public sealed class BmpEncoder : IImageEncoder, IBmpEncoderOptions
     {
         /// <summary>
diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
index 82483e3902..530bcf8cd2 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -9,6 +9,7 @@ using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing.Processors.Quantization;
 using SixLabors.Memory;
 
 namespace SixLabors.ImageSharp.Formats.Bmp
@@ -43,6 +44,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// </summary>
         private const int Rgba32BlueMask = 0xFF;
 
+        /// <summary>
+        /// The color palette for an 8 bit image will have 256 entry's with 4 bytes for each entry.
+        /// </summary>
+        private const int ColorPaletteSize8Bit = 1024;
+
         private readonly MemoryAllocator memoryAllocator;
 
         private Configuration configuration;
@@ -142,11 +148,13 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                 infoHeader.Compression = BmpCompression.BitFields;
             }
 
+            int colorPaletteSize = this.bitsPerPixel == BmpBitsPerPixel.Pixel8 ? ColorPaletteSize8Bit : 0;
+
             var fileHeader = new BmpFileHeader(
                 type: BmpConstants.TypeMarkers.Bitmap,
                 fileSize: BmpFileHeader.Size + infoHeaderSize + infoHeader.ImageSize,
                 reserved: 0,
-                offset: BmpFileHeader.Size + infoHeaderSize);
+                offset: BmpFileHeader.Size + infoHeaderSize + colorPaletteSize);
 
 #if NETCOREAPP2_1
             Span<byte> buffer = stackalloc byte[infoHeaderSize];
@@ -198,6 +206,10 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                 case BmpBitsPerPixel.Pixel16:
                     this.Write16Bit(stream, pixels);
                     break;
+
+                case BmpBitsPerPixel.Pixel8:
+                    this.Write8Bit(stream, image);
+                    break;
             }
         }
 
@@ -276,5 +288,51 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                 }
             }
         }
+
+        /// <summary>
+        /// Writes an 8 Bit image with a color palette. The color palette has 256 entry's with 4 bytes for each entry.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+        /// <param name="stream">The <see cref="Stream"/> to write to.</param>
+        /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
+        private void Write8Bit<TPixel>(Stream stream, ImageFrame<TPixel> image)
+            where TPixel : struct, IPixel<TPixel>
+        {
+#if NETCOREAPP2_1
+            Span<byte> colorPalette = stackalloc byte[ColorPaletteSize8Bit];
+#else
+            byte[] colorPalette = new byte[ColorPaletteSize8Bit];
+#endif
+
+            var quantizer = new WuQuantizer(256);
+            QuantizedFrame<TPixel> quantized = quantizer.CreateFrameQuantizer<TPixel>(this.configuration).QuantizeFrame(image);
+
+            int idx = 0;
+            var color = default(Rgba32);
+            foreach (TPixel quantizedColor in quantized.Palette)
+            {
+                quantizedColor.ToRgba32(ref color);
+                colorPalette[idx] = color.B;
+                colorPalette[idx + 1] = color.G;
+                colorPalette[idx + 2] = color.R;
+
+                // Padding byte, always 0
+                colorPalette[idx + 3] = 0;
+                idx += 4;
+            }
+
+            stream.Write(colorPalette, 0, ColorPaletteSize8Bit);
+
+            for (int y = image.Height - 1; y >= 0; y--)
+            {
+                Span<byte> pixelSpan = quantized.GetRowSpan(y);
+                stream.Write(pixelSpan);
+
+                for (int i = 0; i < this.padding; i++)
+                {
+                    stream.WriteByte(0);
+                }
+            }
+        }
     }
 }
diff --git a/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs b/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs
index 96ec423e7b..92ff092705 100644
--- a/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs
+++ b/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs
@@ -6,7 +6,6 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     /// <summary>
     /// Configuration options for use during bmp encoding
     /// </summary>
-    /// <remarks>The encoder can currently only write 16-bit, 24-bit and 32-bit rgb images to streams.</remarks>
     internal interface IBmpEncoderOptions
     {
         /// <summary>
diff --git a/src/ImageSharp/Processing/Processors/Quantization/QuantizedFrame{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/QuantizedFrame{TPixel}.cs
index 38862ef446..30b8bc8469 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/QuantizedFrame{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/QuantizedFrame{TPixel}.cs
@@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
 
         /// <summary>
         /// Gets the representation of the pixels as a <see cref="Span{T}"/> of contiguous memory
-        /// at row <paramref name="rowIndex"/> beginning from the the first pixel on that row.
+        /// at row <paramref name="rowIndex"/> beginning from the first pixel on that row.
         /// </summary>
         /// <param name="rowIndex">The row.</param>
         /// <returns>The <see cref="Span{T}"/></returns>
diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
index 7e054734e3..42ec3088d9 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
@@ -114,6 +114,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
         [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
         [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
         [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
+        [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
+        [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
         public void Encode_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             // if supportTransparency is false, a v3 bitmap header will be written
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
@@ -126,11 +128,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
         [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
         [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
         [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
+        [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
+        [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
         public void Encode_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 
         [Theory]
         [WithFile(TestImages.Png.GrayAlpha2BitInterlaced, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
+        [WithFile(Bit32Rgba, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
         public void Encode_PreservesAlpha<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 
@@ -139,8 +144,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
         {
             using (Image<TPixel> image = provider.GetImage())
             {
-                // There is no alpha in bmp with 24 bits per pixels, so the reference image will be made opaque.
-                if (bitsPerPixel == BmpBitsPerPixel.Pixel24)
+                // There is no alpha in bmp with less then 32 bits per pixels, so the reference image will be made opaque.
+                if (bitsPerPixel != BmpBitsPerPixel.Pixel32)
                 {
                     image.Mutate(c => c.MakeOpaque());
                 }
diff --git a/tests/ImageSharp.Tests/TestImages.cs b/tests/ImageSharp.Tests/TestImages.cs
index f82278ef5d..62b7ae2ec0 100644
--- a/tests/ImageSharp.Tests/TestImages.cs
+++ b/tests/ImageSharp.Tests/TestImages.cs
@@ -236,6 +236,7 @@ namespace SixLabors.ImageSharp.Tests
             public const string Bit1Pal1 = "Bmp/pal1p1.bmp";
             public const string Bit4 = "Bmp/pal4.bmp";
             public const string Bit8 = "Bmp/test8.bmp";
+            public const string Bit8Gs = "Bmp/pal8gs.bmp";
             public const string Bit8Inverted = "Bmp/test8-inverted.bmp";
             public const string Bit16 = "Bmp/test16.bmp";
             public const string Bit16Inverted = "Bmp/test16-inverted.bmp";
diff --git a/tests/ImageSharp.Tests/TestUtilities/PixelTypes.cs b/tests/ImageSharp.Tests/TestUtilities/PixelTypes.cs
index e4a7572d60..78431f31aa 100644
--- a/tests/ImageSharp.Tests/TestUtilities/PixelTypes.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/PixelTypes.cs
@@ -60,6 +60,8 @@ namespace SixLabors.ImageSharp.Tests
 
         Bgra5551 = 1 << 22,
 
+        Gray8 = 1 << 23,
+
         // TODO: Add multi-flag entries by rules defined in PackedPixelConverterHelper
 
         // "All" is handled as a separate, individual case instead of using bitwise OR
diff --git a/tests/Images/Input/Bmp/pal8gs.bmp b/tests/Images/Input/Bmp/pal8gs.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..66a0d70dc34f6c25554ea15d779f6114bd042f74
GIT binary patch
literal 9254
zcmZ{q1z1&S*M`@O<BTynb|)%|1!91r5-KI3C?Oz7N`rKFNlJ<c2q=m)N{N&L7K#NH
zSlHb<&dm3H|MTvB&Ka*6|Ftd-`|RV{H_zK^EtNFIXA)=PKM~ErRS<p@@bd!=z$<JT
z(a6F4&tKdP{^f@sexM(J{E_<g>qkHR^b_^(-=BW|`Dgm&mtSbWfB`gc;6NHQXb=q^
zJeYp{^;a4)WC#r%I+T9<?Kc`WY#0q6KAc937(pXPj-*keM$zceqiM{TF*J7USQ<BO
z9E~48o+eC~KociUq)C$|(d5aKY08u-G<E7!nm&CxiHV8Pj2Sa%=FFKiYt}3h7Z<15
zvuD$sIde!tLW1VbolEoP&7=AA=hK1(3uxiOg(N8{Nm5c$v}n;Hl9raH#fulyk|j%M
z>C&aNY}qoBk&z);Sy@`Xd^xRHv4Z5}<Y?u}m9%QrDq6jIHOb4%lY)W*DJm+Gl9Cdw
zS+j=Lu3by()~zFDWo1%PQ6W`TRZ>$^BXxCkTEBihX=rGWrluxoX=#zRwl;0puz@yi
z+(<e)I<#riCfdAtGwJH;lAfL(>Fev0fq?;S*|LQU4Gqc2$cT)MjcM!Ftz=?iLZ+ss
zWM*bY=H}*PVPQd*mX>5?WkuH3*0g>5cCxXtAzNEpva_=zdwY9waBv_;M@MpUaw2DE
zXL50Ip&dJRkgKaJxw*NKySqDiczBSfrzd%Nd6BobH~IMZkgu;V`T6;gzrQ~P1O!lE
zU?2qr1yOKtFolGKP-ti<g@uJtcz8HPL_|<zWF$pJMNxEgH0|8ElVW0GC^j~h;^N{c
zK0clj5)vpeF_Cud+C@o8NtB$NOerZTl$x4KX=!Pco}Ny-ckiZ*j11bdXAfm&X42lh
zdnqd`i?Xw`DJLg~a&vPjFE5Ys^Ydx{{{3{|zyT^KD4>G}57MDShp4cykPaU{OhrXS
zR9sw4B_$<PT3SkFWo1-eUQQJi6;xSSNk@(xp`%BSQdLzIRaaM2O-&8e*49#8T^$`e
zc8u!l>*@IM<J8d5K#h%!)YQ~O&CSi!($YdFPMn~VCr?sqYb&+2wNZO}JDoapicX(C
zO=r%Wp|fYt(z$czsH3BU&YwR|7cN|&&dyG{c<~}#x^#&yU%pINu3Vw3SFci6R~L16
zchj|N*Xa87>vZGB4Z3;rCf&Mqi+Xx`sJFM5Zr{F5ckbMwd-v|q{rmT+udk0DJa|A4
zA3mf<j~>zE$B*gBlPC1_=~H_4>=`|O{+wRCctI~;zNA;LUeW8<uj$R3H}v-HTYC5I
z9ld}5o<4l|Kp#JTq)(qd(dW;f>C2Zd^!x9>)7P(G>5o7Dpg;folm7baFZ$1a{zL!$
z?|<ok|N9@&&qGE}nlVp$xuUAJo{5#CyI)vL(w^KyWi^fM=da%CqaXVZ95Q0;r0L>w
zC6_E;wMIo_qn@FurLCi@mw!lPOd<{VZS2(9k}|86we(D^9X$df;?uGYlvFjeo$u;-
z@Zy6B2DZqynQjx9*)|MzHr{{uW$5V1;IB|n)7Ce!c3}MEjNC)zHBD{julDry>px)d
zuu<bDi;2&dTDn|*jjD!@o{_1Qt&^*_e@H}Z;t#(JWBg_EjBn-S5f~Alnth<Os-gA#
z)n4#{WDWz8cVNwhPCpJ9I%e`r@D)`z=rjHPy#8{gzw1`t&jSVx9WiFYlo@m8FIu`{
z^%_;pje17gENz|KnEu#ZKM3`!{H;H`fa&kx^fRQ$fEAgAIi|S<^&2>B%#@k)!RPgR
z{6qi1!9$0Q8arv~%sC4dEnA_mMom*k&v=`at+SiAe`qB14;VIf+V}LM^`QSfrxZ{N
z?gvn~CBT-<vBvZpG;HkTS@Rcz5B=6c{e_%<wEwR|hm9OFe)9BLa~Dd>$SJH-)6&s5
zHnXyGcJ~elje`Dx!^Uy_&+GT(`k&L!_dlnSDdi1FfmvB%d9$MagNKiu0=^vh25bOv
z`twBnKWzBO(c>mg6`MU*a<S}6#dYdhoAtMvS=+g|`2>VU#_jrX;P7$KFC(wahVQ@o
zpVP^dS^~&Bu+~Dy@E<X5s`&gRa!Sx|3O@Qjc~35{zpJNj<mfTuCQg|?a}FDRs}z;j
zYi~B#YHn@s;^7k*8WorH;~?<ofd8-l=k+tB$bc2uc55u_+iBp?k>jU{FIc=%NqvI>
z#}5ZT?@&ceQ~L$9|JbqPCrp_(Lww#s>7{b3G5t2^ZZR?6Zok9BH!v(JKB?cJ5#y%M
zmg4lATK}!TQPBS)r2qrTJHR%))1YCaCQO^XV5!_1^^M>=L4Pc#zqSeEzo&1)#7V%<
zl9(^GSXNG9t*XXGT|*NK8;2d9zCmHp@yY!Lj~Fk|kKyCQ^*=xUdHoFdjR7k%Y-hGK
zWcZkgVzVWet^|LJ>2~nL!Otrc>Yp-Y+VmN-=FD5TXc=pMHvHK1b9D9e3kr`;NbWy)
z<oM}xq+}FSwDoxX32EH?=k&k)AkYb@?cZ)|Cv+M*a_l5A3CU$E*Mh$d`~dJX^9swM
z{{m+4bTP4+;&bLMkXj-mC%=YuzdoCOPOe^l!4WYDDgB3xoG@KNN>*NlEniNafsyfP
zBK;3vd|*(K0V^_lJ8a|jG#qQ&ObMxFtJbau-v$jB9-G4SbNt@ES+m4vOUzp+xp>)%
zm5OWCG&XMD!iJxdyH`Lkmfw`0hm4vaHfPbl^z;4y@`Fezz(Dd2umkUewQcImxl%H#
z)~(lperNFGQZn-ngMW(YpCchLZ~j85#Y<)7<du}wwREuhWB9qav*{O`nEK1mQ4__W
zUqSU-{iW61`Vaj)mPzFdSdlq8;QTUr+@xvZ^Q2|u*J<b&ZnJUr3W$hJ$;^lTX0(5A
z-~9Ot7DzJuiq(qiR5e)hn_Aj9?(p;p!t#@pI`FsA;4hL@P+`;8*)uSL?|-3wfldw!
zAn!OhIq^<oCrlQbJzrW@URh(4p_vVPKwQdR=&ytR?w$vdQc{bgmn@TAu}Wc$in``T
z-7Q<O`Z@8#FFq-K;4o~Ta~CaV`Z0V3{m<*~g?<Kf<bLpr8Ni%5JK@;oOyeg_oiS&@
z;^hj;nwyNwY@NNpPtD9fTv^+Es<W&2!D8tpOP0wjU$I(Y%{n!W4V(0hSo5>hKO{UR
zJ~@5x@G+BS&XtyB+ZWRx6q%5gQ&3tZ)GyG<L4o8QU>DvAYuhXd$t5ckRJ3%B%xzu3
zk5Ap3UsO@o4E?<imM)W#UA|%^!>g{>(t-SKmNpJp{Q}tTpOW$Gh_P(@#PI>k*LM8*
zkqPP91%K;@R$eJn%VBX+<!y%x&a0EBVr`RLCa0vLt!r#<=i-eCl)88S;mW#}Q=Q$n
zA1q%kC%1ByJj1JNZP=`DWMW~>H9uCrxWv?qp(Dmko;7bV<Lk5G`?r3Ko(C^K2y`;F
zFd%uyQQ4I_O%=n^zG&G>B{gk5V+*?--a+7J<rh`fHJ|S6?tO^(V70uW(pqIzb<GW%
z^w9fEKAJx`JUT8ZE%Ucg<FI|P?R$d(_`LpurPb{8!1|w)%9IKXP?5R0lGqG!iG|X#
ztJbP*&@-{L-{BJ!g#*<7q9fnLW1>slE$Dq~TmF6I&V=OMnZrj<!1l%80iVA>`!}{h
z|HGFbIF(E(%uVPB5ZrmE8RB#1;b13^<qyXndsm;}s08qfzsn~wF|)F9;2}}5i7C6Y
zhL4$m?MuM75%5L&Uw-7V016F(iNHME5ub?9p1WYtQaO3$^*RQoRt~Pd!O;onSqGSY
z99REgz*t(_JF<_6cE%;8?#agTjqQuSW47IezbGgZ=@;l^YGFX~j?l=HInACsPZ9?k
zMP*H$EvD8EZoVPWiRsw~nErpj*<1VpwhjVFOhR&cX3nVblf-5(<gr-3_zPY?M$gNS
zoK~h(Xn=~$%ai8LTPU?ec9o*4=H@NitR3C_LUtzZ&MqiE%0G#3Sivjz2iQCB;6K9X
z-<`E@%=jr{5(2)Njo?o^SXRw;uiNN<P9;++FfUKuy}dZ6c?%?^xpS@7W+O9fe}17m
zckRw8DES_rYj&p{?mRy}DQ!=7-q?v#W=Kf#cg$=>e4L)KdO$yi1yW?dip<BG7D`Gl
zVFwF!Z9OA%8)pyy(3o8rIR{Is_(wj{)z#C}*WY4jycLbWI>5!<lfS^|%iNbgZsN3=
za|L{J8$r{E^uPM(#p`6RFdv~K6!v9KQqqgLgT?xdnEtkG`-@4+*mtm0z<+FjfZfo@
zc&o`aa~|vF;lp1r`MC$iPo6ew?jrsUmQVfy(G%M}Za;eYk<$vS$N&|YpD#%-UMj=R
zb($Luwp!Y{cm{^YChggGsI;1Y(qm)et;QxM+qRioSn+o}y#4r#l=Qth`3EOXL1ZN2
z3-y<?{_np1@YP3Op;D$6<|lL{0sQ^^37gA`l?rRsv^E)-V)^k7j9|yVLuEof3!M<P
zSXx;N+TYtZkmslE$;v%Yi0up8Cx6G>PQd?0zd$Q!A_G=r1iYNQqO!X7W<yhJdspwE
zh`8j;+`_UN{*nI}|3ttC^B?Wb%*i{592O!Y0pG&T^*i4prjt2m0saCH2xLyOE96!w
zti`cf&&bT$(bXp?k{y3={Qvip*y!{24G0S3KVtIPpEpZl;S&Cih5dK=L_mrRP>}@%
zA`i7nUTGboIz&}Aj_y7oQ3<Iyew5d;NB+Zze0&3g!XkJYdY`{QV9sAy^7{YrEw*TJ
zS~+k~pumyz2@VRTmDt^Iu+iRRu+_rG+1)QBIw5UuK8}Ci<@*N)hebs5wCp_opAbnd
z74Uie|Kzhj08o(uD>CHW6xS%LY9gvJwX}2g^b3tnOvCnDQO7@$HL%cF`!jqD|4}ag
zi`^CR-TwV8){Ni-%3(u-1&(A_Xh<k2D6Ltif`bi$dMo=Ko&jMy+47I=|GQ5jij0nl
z7k<PZ{Oz@s!}s{yss&mwegp<EXJMhpGp<us$GOhH*v#5thc{b((sK?JS03XZ{EV$z
zSgU;f0|cnpghT<8;j6^Id1K|^&c9=)=TjH2-Ffu-li*uSD+dh=6*!W7;bGylPFY25
zy%vtOCgwJdZkT?tNf|i>#YY7E=a{wr7`=f(!6E#!6LzKW7Yu*2cDBUd?~pwa@^N|s
z|M9C&q5K^{MFy<MkXKbx*VNvGoQ@@O8ooi1u_+n*3QCXG^WS^U22L=VE=)M=ccr9p
zA2IxqnqvsfL~jwj^WQ40tZf1RF7yi~E7Qsx7Qs7`n-LL_q^7=JQ(I><njbk058sfe
z_>?`lSpJ24^b;B?JR&km(2}X?84SYkmDRP!CFU>WR$uns+DV`v(L>9bi`VZwe*IbS
zEe^{eIcx;ds+`e!4Na|$oAmjZ-qSxMIzBZs?@(FQab5|&{*5t6`kqXVPgGG=Q{Omm
zft0k2;0Ctu|L<E7k<4LHLPt_JIx3npwX`>G(ly|MDp&7-FigL_d4*-w-{W(lGqZAd
zNX5~bV+}2c4VTEQ<nMf+&wUHnZwz38k@f~19bJ7xE~s+%4hoA&OwZb1SW(@`X=3gC
zt)VTl_T}OuqVl8F$Bs9jVCM&<CAnLOp8vmZF|EvDJB5yPb_{LQ*`%w##n{vWF|CI$
z8~*9p`->`SzRL$bCpV8<^(&54*Bx&<(I&YFkvY<Wtd|fyevgk&cr1Xt#q2~Hoio%3
zboI6vnQXH{OzY(r5*e42!Iq!eCicL8+rGT~0&IFreO-N1OWP>~r$|h!Rnx{zM34Xe
z2D`HpK;|(#I5vj&xY#(-)x+Uxt0@br+`N#{!|>l%P+VE}T|Vds4jwAP&|~<<mex~e
z7a=rXsjyCcgC6)U-{td4f&9i$KHv;B5kteRCgzqlTuLD<Iw2)<-@%fjbuGw#-MaVm
zb!O(?%)NWFvT}0v<>u!fC^%GDTvE>Cn_Jt@b}U{Z!=>dm>TR{)qerBli;f;UdFJws
zdr#hc=CM%9JD~AGNBJUw42_JonwVKw+ajgl8x$VHhW{ZfKP{&(bltlD^bP70K<~@V
z%g^5r?T3p>N-HX>YM{RPWc!(Ook$JHtyWUjV8=HudPMYu=%N1PS@55}`6AHCVFBbV
zAs%HD&QJp~F)=f@+V0?tgfcQZN$FXbepU4+P9yri|LjeE9z1{l{(^#o2MZ4u7nhY+
z9;vQ5R^Qaz+IHsLg-gf{ATOn=vB|*1(gDYpC>A{xALaP>pS=C@4Kf~B4xE@E@Wezi
zF*P+ax7=>$xPxVMkkH(nz5j4|_3@KuE+YDW_Vxe@F+d+WRCu_kxTLha;z(6ZZGA&i
zODoi0xO5e%37nr)wKi>G(Hn~%v3-^tJ$~}s<(v1OzWpK;ir;{WY*!)*MyzIpldZXx
zwXMCgD@!Quj8DnP*<Vy%)6jbM(zV+Up1&<DJY0DAa8XflacOBev{zNv)*WwX=J6M=
zcFQhbxmt;3g|}?8a&+UON0xp&-g@@R&HLc<P~dpyph>$pN4YAQke{})wy|?`aYyq<
z>`Y9}WW&F<vGv@g>$e|1e^*>mTvAe6T2@wGQF-Jj=*O7&6K$uM`YYWxmb3F4j<32#
zh~C_}=#iygj<-Vp{bz4~=YZ@5NRcHcp-jdZSy@_J+uAugyLtGsgxaq3%)EjUOuzPX
zm#^P>_~ISvTjdoMm6b;Tuc@i4t3Te@bmC<Dsk0rOP=Di=98xoa<Lh=O9N!Q<vgir?
zD>wU|zWX9lngl3wSc=e5r?cK}V{7Mtpw7z=`P{f<3_lG2W6ka7uiUu%=;enaD5xE+
zs;aJLaA<FAZaLX{>h!se&Pxn`8|OzQmKD}BHn$N(k1Tp>XzjRii|OZOa<9OOEHwoM
zLKteAc6N?VJ6t_|0?_;k$r;)E3(GM5PMyDc^WNiEA8Kl9;dQmgj@8#UG&D7zIMLRA
z`b@|9i#+}=JHE24uz@j-uYB|fKGKgJC|*5#_qz}ZAn$;t2_5xGJ9`I5Cl^;lRe@YS
zbI-m5Z1|rz&6b}huRb2D2N*@ehQ`LG=9UvD+uG6d=Pz8m+;t7=@Ak<nD6Pf$5z~)F
zkF0ov=#ix#Sn=%nyRV!|_9B3yCdyfQdKyZj>8Rm4LA|@DuYWL_KPheRzJj94nuZf+
zI=gT6J$d~Rb;`!3#-^s0mJ=shTic=iT*rmZ%U8Ou-R!w@x9_2%BJzUkH*7XE!SaLS
zD;GVM)ikt2|AS}mf9J3u0>?X`yM>Ortdp|~!}~D#ETNQ@cd&#F|Ff9>eNW$fMr{<O
zQB+1-q5SljvrPM?D_5^wztwx^-h)R^71yj)QA1kP&=kjKBoDdh5yd0u?_v5ml}ssz
zMJ1TGjNK>*vzjpSaBdzR2&;m_kx)v_$jL7(JzCe)hUv$apU-WrZEfvs?d_*dodLY#
zd}rt7%Uxa9Z}jxuW%%c7)+(#4M@<aV&)(Hb5IvUHHnQTygXizRa$3OzQ0Tz!5jtw+
z?jD}rzWza>5j&C5$VB&-RblvdTxQe%?HAO4QT{!1mazf9c=^iJ?rS%0_TIjC|Ka1O
z&tCzrrlHNEH*2>1^3fw#yg>T##rr=vmBJTbMV7e-rSMGD=si7seEkDM!lGgllXvgU
zEhs9lu5V$}@6Mwa@4s}M>*zQS^o0wZotG|Mxzg2r{rat*+js8wJ$n4?#p^f9Tw;>d
zq;P!q366~ClGiMG-`#`s<5x~8puq7CD0WodQHN*Y1@OV>{kUDJ8QFOUi`nqQ@V|-a
z|Nbj#+$eEhymaX@ly`MsyMFUl4|=}u!Q&^-U%Y<%K}A(fg9{%lY@FPEgQHmT7||o2
zJbv-v4^AahD!`)l&l~;&01W>p!Ot%sAUGr<DmFejEi-5Tq0%FD4XtN7yD<G;e)xLj
zGOFrVu3qix>W1>0H+!J{-u(v;pFDl>^3B^1pH$V>qxn&ku&{Mv$M*!5yhZZ*^o46I
z{rZPU>E0}%1Dh>$BnSKh0)s=snfw$qKe`{oj}8Bx`<Q-zppM^-I{x+RH*P>V;CG?@
z5qkdRt2ggHe*PVJE-k%{g%60H5xwpgB#&A8?awS=MFy<Ma<bXU0+D%8P)JC4#Ln1+
zq%_w2MHN-`%~<`f_4Yk`{prt}H{dsK0o~hs=g!@`eSHrfK6&!|`K#CO-hcZ1^-tgh
l;fuYCr+;YlE*xJGJvN`|yvEW`e{xCz1&(({h3(^={twNu&_w_M

literal 0
HcmV?d00001


From 6401344f8a5c9c7c86ebee097e68d39cc6be9ce8 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Tue, 7 May 2019 20:43:12 +0200
Subject: [PATCH 2/8] Changed WuQuantizer to OctreeQuantizer

---
 src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
index 530bcf8cd2..0ef2046a84 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -304,7 +304,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             byte[] colorPalette = new byte[ColorPaletteSize8Bit];
 #endif
 
-            var quantizer = new WuQuantizer(256);
+            var quantizer = new OctreeQuantizer(256);
             QuantizedFrame<TPixel> quantized = quantizer.CreateFrameQuantizer<TPixel>(this.configuration).QuantizeFrame(image);
 
             int idx = 0;

From 6ce4efe1783d576b5bd59de25dbdef397146142c Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Thu, 9 May 2019 20:35:19 +0200
Subject: [PATCH 3/8] Trying MagickReferenceDecoder for the 8bit greyscale
 image encoder tests

---
 .../Formats/Bmp/BmpEncoderTests.cs            | 50 +++++++++++++++----
 1 file changed, 39 insertions(+), 11 deletions(-)

diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
index 42ec3088d9..a56cee47d8 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
@@ -2,10 +2,13 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs;
 
 using Xunit;
 using Xunit.Abstractions;
@@ -110,13 +113,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
         [WithFile(Bit32Rgba, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
         [WithFile(WinBmpv4, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
         [WithFile(WinBmpv5, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
-        // WinBmpv3 is a 24 bits per pixel image
-        [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
-        [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
-        [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
-        [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
-        [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
-        public void Encode_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+        public void Encode_32Bit_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             // if supportTransparency is false, a v3 bitmap header will be written
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
 
@@ -125,13 +122,44 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
         [WithFile(Bit32Rgba, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
         [WithFile(WinBmpv4, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
         [WithFile(WinBmpv5, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
+        public void Encode_32Bit_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
+
+        [Theory]
+        // WinBmpv3 is a 24 bits per pixel image
+        [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
+        public void Encode_24Bit_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
+
+        [Theory]
         [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
+        public void Encode_24Bit_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
+
+
+        [Theory]
+        [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
+        [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
+        public void Encode_16Bit_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
+
+        [Theory]
         [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
         [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
+        public void Encode_16Bit_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
+
+        [Theory]
         [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
         [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
-        public void Encode_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
-            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
+        public void Encode_8Bit_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false, referenceDecoder: new MagickReferenceDecoder());
+
+        [Theory]
+        [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
+        [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
+        public void Encode_8Bit_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true, referenceDecoder: new MagickReferenceDecoder());
 
         [Theory]
         [WithFile(TestImages.Png.GrayAlpha2BitInterlaced, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
@@ -139,7 +167,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
         public void Encode_PreservesAlpha<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 
-        private static void TestBmpEncoderCore<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel, bool supportTransparency = true)
+        private static void TestBmpEncoderCore<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel, bool supportTransparency = true, IImageDecoder referenceDecoder = null)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> image = provider.GetImage())
@@ -153,7 +181,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
                 var encoder = new BmpEncoder { BitsPerPixel = bitsPerPixel, SupportTransparency = supportTransparency };
 
                 // Does DebugSave & load reference CompareToReferenceInput():
-                image.VerifyEncoder(provider, "bmp", bitsPerPixel, encoder);
+                image.VerifyEncoder(provider, "bmp", bitsPerPixel, encoder, referenceDecoder: referenceDecoder);
             }
         }
     }

From b5df1c785c0929c117fcd2d28e0f68e0e838a1d3 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Thu, 9 May 2019 22:07:04 +0200
Subject: [PATCH 4/8] Setting dither to false in the OctreeQuantizer

---
 src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs   |  2 +-
 .../Processors/Quantization/OctreeQuantizer.cs | 18 ++++++++++++++----
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
index 0ef2046a84..be82e2cab3 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -304,7 +304,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             byte[] colorPalette = new byte[ColorPaletteSize8Bit];
 #endif
 
-            var quantizer = new OctreeQuantizer(256);
+            var quantizer = new OctreeQuantizer(dither: false, maxColors: 256);
             QuantizedFrame<TPixel> quantized = quantizer.CreateFrameQuantizer<TPixel>(this.configuration).QuantizeFrame(image);
 
             int idx = 0;
diff --git a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs
index d49023886b..f5fa8c95d9 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs
@@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Initializes a new instance of the <see cref="OctreeQuantizer"/> class.
         /// </summary>
-        /// <param name="dither">Whether to apply dithering to the output image</param>
+        /// <param name="dither">Whether to apply dithering to the output image.</param>
         public OctreeQuantizer(bool dither)
             : this(GetDiffuser(dither), QuantizerConstants.MaxColors)
         {
@@ -44,7 +44,17 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Initializes a new instance of the <see cref="OctreeQuantizer"/> class.
         /// </summary>
-        /// <param name="diffuser">The error diffusion algorithm, if any, to apply to the output image</param>
+        /// <param name="maxColors">The maximum number of colors to hold in the color palette.</param>
+        /// <param name="dither">Whether to apply dithering to the output image.</param>
+        public OctreeQuantizer(bool dither, int maxColors)
+            : this(GetDiffuser(dither), maxColors)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OctreeQuantizer"/> class.
+        /// </summary>
+        /// <param name="diffuser">The error diffusion algorithm, if any, to apply to the output image.</param>
         public OctreeQuantizer(IErrorDiffuser diffuser)
             : this(diffuser, QuantizerConstants.MaxColors)
         {
@@ -53,8 +63,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Initializes a new instance of the <see cref="OctreeQuantizer"/> class.
         /// </summary>
-        /// <param name="diffuser">The error diffusion algorithm, if any, to apply to the output image</param>
-        /// <param name="maxColors">The maximum number of colors to hold in the color palette</param>
+        /// <param name="diffuser">The error diffusion algorithm, if any, to apply to the output image.</param>
+        /// <param name="maxColors">The maximum number of colors to hold in the color palette.</param>
         public OctreeQuantizer(IErrorDiffuser diffuser, int maxColors)
         {
             this.Diffuser = diffuser;

From e0afde9967924a0d54a98479ea99f42c224b32a8 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Fri, 10 May 2019 20:28:46 +0200
Subject: [PATCH 5/8] Switched back to the default reference decoder

---
 tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
index a56cee47d8..f3d6e0fa8e 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
@@ -153,13 +153,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
         [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
         [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
         public void Encode_8Bit_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
-            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false, referenceDecoder: new MagickReferenceDecoder());
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
 
         [Theory]
         [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
         [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
         public void Encode_8Bit_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
-            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true, referenceDecoder: new MagickReferenceDecoder());
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 
         [Theory]
         [WithFile(TestImages.Png.GrayAlpha2BitInterlaced, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
@@ -167,7 +167,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
         public void Encode_PreservesAlpha<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 
-        private static void TestBmpEncoderCore<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel, bool supportTransparency = true, IImageDecoder referenceDecoder = null)
+        private static void TestBmpEncoderCore<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel, bool supportTransparency = true)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> image = provider.GetImage())
@@ -181,7 +181,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
                 var encoder = new BmpEncoder { BitsPerPixel = bitsPerPixel, SupportTransparency = supportTransparency };
 
                 // Does DebugSave & load reference CompareToReferenceInput():
-                image.VerifyEncoder(provider, "bmp", bitsPerPixel, encoder, referenceDecoder: referenceDecoder);
+                image.VerifyEncoder(provider, "bmp", bitsPerPixel, encoder);
             }
         }
     }

From e8695732b6c3367d30003cb2e563119312a58a36 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Sat, 11 May 2019 13:52:18 +0200
Subject: [PATCH 6/8] Using tolerant comparer for the Bit8Gs image

---
 src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs  |  3 +-
 .../Formats/Bmp/BmpEncoderTests.cs            | 37 ++++++++++++++++---
 2 files changed, 33 insertions(+), 7 deletions(-)

diff --git a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
index 9d9c7b624a..0cbc4fca1b 100644
--- a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
@@ -1022,7 +1022,8 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             this.bmpMetadata.InfoHeaderType = infoHeaderType;
 
             // We can only encode at these bit rates so far.
-            if (bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel16)
+            if (bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel8)
+                || bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel16)
                 || bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel24)
                 || bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel32))
             {
diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
index f3d6e0fa8e..1d489e69dc 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
@@ -3,12 +3,11 @@
 
 using System.IO;
 
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
-using SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs;
+using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 
 using Xunit;
 using Xunit.Abstractions;
@@ -128,11 +127,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
         [Theory]
         // WinBmpv3 is a 24 bits per pixel image
         [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
+        [WithFile(F, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
         public void Encode_24Bit_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
 
         [Theory]
         [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
+        [WithFile(F, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
         public void Encode_24Bit_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 
@@ -150,24 +151,48 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 
         [Theory]
+        [WithFile(WinBmpv5, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
         [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
-        [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
         public void Encode_8Bit_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
 
         [Theory]
+        [WithFile(WinBmpv5, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
         [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
-        [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
         public void Encode_8Bit_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 
+        [Theory]
+        [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
+        public void Encode_8BitGray_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> =>
+            TestBmpEncoderCore(
+                provider,
+                bitsPerPixel,
+                supportTransparency: false,
+                ImageComparer.TolerantPercentage(0.01f));
+
+        [Theory]
+        [WithFile(Bit8Gs, PixelTypes.Gray8, BmpBitsPerPixel.Pixel8)]
+        public void Encode_8BitGray_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> =>
+            TestBmpEncoderCore(
+                provider,
+                bitsPerPixel,
+                supportTransparency: true,
+                ImageComparer.TolerantPercentage(0.01f));
+
         [Theory]
         [WithFile(TestImages.Png.GrayAlpha2BitInterlaced, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
         [WithFile(Bit32Rgba, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
         public void Encode_PreservesAlpha<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 
-        private static void TestBmpEncoderCore<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel, bool supportTransparency = true)
+        private static void TestBmpEncoderCore<TPixel>(
+            TestImageProvider<TPixel> provider,
+            BmpBitsPerPixel bitsPerPixel,
+            bool supportTransparency = true,
+            ImageComparer customComparer = null)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> image = provider.GetImage())
@@ -181,7 +206,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Bmp
                 var encoder = new BmpEncoder { BitsPerPixel = bitsPerPixel, SupportTransparency = supportTransparency };
 
                 // Does DebugSave & load reference CompareToReferenceInput():
-                image.VerifyEncoder(provider, "bmp", bitsPerPixel, encoder);
+                image.VerifyEncoder(provider, "bmp", bitsPerPixel, encoder, customComparer);
             }
         }
     }

From 7b8f9ef14f45e95aafb76f52dfe7fcda0e8339f7 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Sat, 11 May 2019 16:27:51 +0200
Subject: [PATCH 7/8] Enabled dither again

---
 src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
index be82e2cab3..8d0e8578d1 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -304,7 +304,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             byte[] colorPalette = new byte[ColorPaletteSize8Bit];
 #endif
 
-            var quantizer = new OctreeQuantizer(dither: false, maxColors: 256);
+            var quantizer = new OctreeQuantizer(dither: true, maxColors: 256);
             QuantizedFrame<TPixel> quantized = quantizer.CreateFrameQuantizer<TPixel>(this.configuration).QuantizeFrame(image);
 
             int idx = 0;

From b1d29476d10eb9ddac35811cd687870ec41ed319 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Sun, 12 May 2019 18:38:22 +0200
Subject: [PATCH 8/8] Review changes

---
 src/ImageSharp/Formats/Bmp/BmpEncoder.cs      |  7 +++
 src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs  | 61 ++++++++++---------
 .../Formats/Bmp/IBmpEncoderOptions.cs         |  9 ++-
 3 files changed, 47 insertions(+), 30 deletions(-)

diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoder.cs b/src/ImageSharp/Formats/Bmp/BmpEncoder.cs
index f3eb9282ce..612675c33c 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoder.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoder.cs
@@ -4,6 +4,7 @@
 using System.IO;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing.Processors.Quantization;
 
 namespace SixLabors.ImageSharp.Formats.Bmp
 {
@@ -25,6 +26,12 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// </summary>
         public bool SupportTransparency { get; set; }
 
+        /// <summary>
+        /// Gets or sets the quantizer for reducing the color count for 8-Bit images.
+        /// Defaults to OctreeQuantizer.
+        /// </summary>
+        public IQuantizer Quantizer { get; set; }
+
         /// <inheritdoc/>
         public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             where TPixel : struct, IPixel<TPixel>
diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
index 8d0e8578d1..90ea673d3e 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Buffers;
 using System.IO;
 
 using SixLabors.ImageSharp.Advanced;
@@ -62,6 +63,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// </summary>
         private readonly bool writeV4Header;
 
+        /// <summary>
+        /// The quantizer for reducing the color count for 8-Bit images.
+        /// </summary>
+        private readonly IQuantizer quantizer;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="BmpEncoderCore"/> class.
         /// </summary>
@@ -72,6 +78,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             this.memoryAllocator = memoryAllocator;
             this.bitsPerPixel = options.BitsPerPixel;
             this.writeV4Header = options.SupportTransparency;
+            this.quantizer = options.Quantizer ?? new OctreeQuantizer(dither: true, maxColors: 256);
         }
 
         /// <summary>
@@ -298,39 +305,35 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         private void Write8Bit<TPixel>(Stream stream, ImageFrame<TPixel> image)
             where TPixel : struct, IPixel<TPixel>
         {
-#if NETCOREAPP2_1
-            Span<byte> colorPalette = stackalloc byte[ColorPaletteSize8Bit];
-#else
-            byte[] colorPalette = new byte[ColorPaletteSize8Bit];
-#endif
-
-            var quantizer = new OctreeQuantizer(dither: true, maxColors: 256);
-            QuantizedFrame<TPixel> quantized = quantizer.CreateFrameQuantizer<TPixel>(this.configuration).QuantizeFrame(image);
-
-            int idx = 0;
-            var color = default(Rgba32);
-            foreach (TPixel quantizedColor in quantized.Palette)
+            using (IMemoryOwner<byte> colorPaletteBuffer = this.memoryAllocator.AllocateManagedByteBuffer(ColorPaletteSize8Bit, AllocationOptions.Clean))
+            using (QuantizedFrame<TPixel> quantized = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration, 256).QuantizeFrame(image))
             {
-                quantizedColor.ToRgba32(ref color);
-                colorPalette[idx] = color.B;
-                colorPalette[idx + 1] = color.G;
-                colorPalette[idx + 2] = color.R;
-
-                // Padding byte, always 0
-                colorPalette[idx + 3] = 0;
-                idx += 4;
-            }
-
-            stream.Write(colorPalette, 0, ColorPaletteSize8Bit);
+                Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
+                int idx = 0;
+                var color = default(Rgba32);
+                foreach (TPixel quantizedColor in quantized.Palette)
+                {
+                    quantizedColor.ToRgba32(ref color);
+                    colorPalette[idx] = color.B;
+                    colorPalette[idx + 1] = color.G;
+                    colorPalette[idx + 2] = color.R;
+
+                    // Padding byte, always 0
+                    colorPalette[idx + 3] = 0;
+                    idx += 4;
+                }
 
-            for (int y = image.Height - 1; y >= 0; y--)
-            {
-                Span<byte> pixelSpan = quantized.GetRowSpan(y);
-                stream.Write(pixelSpan);
+                stream.Write(colorPalette);
 
-                for (int i = 0; i < this.padding; i++)
+                for (int y = image.Height - 1; y >= 0; y--)
                 {
-                    stream.WriteByte(0);
+                    Span<byte> pixelSpan = quantized.GetRowSpan(y);
+                    stream.Write(pixelSpan);
+
+                    for (int i = 0; i < this.padding; i++)
+                    {
+                        stream.WriteByte(0);
+                    }
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs b/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs
index 92ff092705..59ad929df7 100644
--- a/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs
+++ b/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs
@@ -1,10 +1,12 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using SixLabors.ImageSharp.Processing.Processors.Quantization;
+
 namespace SixLabors.ImageSharp.Formats.Bmp
 {
     /// <summary>
-    /// Configuration options for use during bmp encoding
+    /// Configuration options for use during bmp encoding.
     /// </summary>
     internal interface IBmpEncoderOptions
     {
@@ -20,5 +22,10 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// Instead a bitmap version 4 info header will be written with the BITFIELDS compression.
         /// </summary>
         bool SupportTransparency { get; }
+
+        /// <summary>
+        /// Gets the quantizer for reducing the color count for 8-Bit images.
+        /// </summary>
+        IQuantizer Quantizer { get; }
     }
 }
\ No newline at end of file