Decoding Bitmaps with BITFIELDS masks

src/ImageSharp/Formats/Bmp/BmpCompression.cs

@@ -25,7 +25,6 @@ internal enum BmpCompression : int
         /// If the first byte is zero, the record has different meanings, depending
         /// on the second byte. If the second byte is zero, it is the end of the row,
         /// if it is one, it is the end of the image.
-        /// Not supported at the moment.
         /// </summary>
         RLE8 = 1,
 
@@ -42,7 +41,6 @@ internal enum BmpCompression : int
         /// <summary>
         /// Each image row has a multiple of four elements. If the
         /// row has less elements, zeros will be added at the right side.
-        /// Not supported at the moment.
         /// </summary>
         BitFields = 3,
 

src/ImageSharp/Formats/Bmp/BmpConstants.cs

@@ -19,5 +19,41 @@ internal static class BmpConstants
         /// The list of file extensions that equate to a bmp.
         /// </summary>
         public static readonly IEnumerable<string> FileExtensions = new[] { "bm", "bmp", "dip" };
+
+        /// <summary>
+        /// Valid magic bytes markers identifying a Bitmap file.
+        /// </summary>
+        internal static class TypeMarkers
+        {
+            /// <summary>
+            /// Single-image BMP file that may have been created under Windows or OS/2.
+            /// </summary>
+            public const int Bitmap = 0x4D42;
+
+            /// <summary>
+            /// OS/2 Bitmap Array.
+            /// </summary>
+            public const int BitmapArray = 0x4142;
+
+            /// <summary>
+            /// OS/2 Color Icon.
+            /// </summary>
+            public const int ColorIcon = 0x4943;
+
+            /// <summary>
+            /// OS/2 Color Pointer.
+            /// </summary>
+            public const int ColorPointer = 0x5043;
+
+            /// <summary>
+            /// OS/2 Icon.
+            /// </summary>
+            public const int Icon = 0x4349;
+
+            /// <summary>
+            /// OS/2 Pointer.
+            /// </summary>
+            public const int Pointer = 0x5450;
+        }
     }
 }

src/ImageSharp/Formats/Bmp/BmpDecoder.cs

@@ -15,8 +15,6 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     ///    <item>JPG</item>
     ///    <item>PNG</item>
     ///    <item>RLE4</item>
-    ///    <item>RLE8</item>
-    ///    <item>BitFields</item>
     /// </list>
     /// Formats will be supported in a later releases. We advise always
     /// to use only 24 Bit Windows bitmaps.

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -23,6 +23,26 @@ internal sealed class BmpEncoderCore
         /// </summary>
         private int padding;
 
+        /// <summary>
+        /// The mask for the alpha channel of the color for a 32 bit rgba bitmaps.
+        /// </summary>
+        private const int Rgba32AlphaMask = 0xFF << 24;
+
+        /// <summary>
+        /// The mask for the red part of the color for a 32 bit rgba bitmaps.
+        /// </summary>
+        private const int Rgba32RedMask = 0xFF << 16;
+
+        /// <summary>
+        /// The mask for the green part of the color for a 32 bit rgba bitmaps.
+        /// </summary>
+        private const int Rgba32GreenMask = 0xFF << 8;
+
+        /// <summary>
+        /// The mask for the blue part of the color for a 32 bit rgba bitmaps.
+        /// </summary>
+        private const int Rgba32BlueMask = 0xFF;
+
         private readonly MemoryAllocator memoryAllocator;
 
         private Configuration configuration;
@@ -92,8 +112,9 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
                 }
             }
 
+            int infoHeaderSize = BmpInfoHeader.SizeV4;
             var infoHeader = new BmpInfoHeader(
-                headerSize: BmpInfoHeader.Size,
+                headerSize: infoHeaderSize,
                 height: image.Height,
                 width: image.Width,
                 bitsPerPixel: bpp,
@@ -102,26 +123,37 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
                 clrUsed: 0,
                 clrImportant: 0,
                 xPelsPerMeter: hResolution,
-                yPelsPerMeter: vResolution);
+                yPelsPerMeter: vResolution)
+            {
+                RedMask = Rgba32RedMask,
+                GreenMask = Rgba32GreenMask,
+                BlueMask = Rgba32BlueMask,
+                Compression = BmpCompression.BitFields
+            };
+
+            if (this.bitsPerPixel == BmpBitsPerPixel.Pixel32)
+            {
+                infoHeader.AlphaMask = Rgba32AlphaMask;
+            }
 
             var fileHeader = new BmpFileHeader(
-                type: 19778, // BM
-                fileSize: 54 + infoHeader.ImageSize,
+                type: BmpConstants.TypeMarkers.Bitmap,
+                fileSize: BmpFileHeader.Size + infoHeaderSize + infoHeader.ImageSize,
                 reserved: 0,
-                offset: 54);
+                offset: BmpFileHeader.Size + infoHeaderSize);
 
 #if NETCOREAPP2_1
-            Span<byte> buffer = stackalloc byte[40];
+            Span<byte> buffer = stackalloc byte[infoHeaderSize];
 #else
-            byte[] buffer = new byte[40];
+            byte[] buffer = new byte[infoHeaderSize];
 #endif
             fileHeader.WriteTo(buffer);
 
             stream.Write(buffer, 0, BmpFileHeader.Size);
 
-            infoHeader.WriteTo(buffer);
+            infoHeader.WriteV4Header(buffer);
 
-            stream.Write(buffer, 0, 40);
+            stream.Write(buffer, 0, infoHeaderSize);
 
             this.WriteImage(stream, image.Frames.RootFrame);