Fix parsing of bitmap resources (#156)

Author: TerryFogg

MetadataProcessor.Shared/Tables/nanoResourcesTable.cs

@@ -79,9 +79,16 @@ public void Write(
 
                         if (kind == ResourceKind.Bitmap)
                         {
+                            // Bitmaps at this stage are byte arrays with a 4 byte length prefix
                             using (var stream = new MemoryStream(resourceData.Length))
                             {
-                                var bitmapProcessor = new nanoBitmapProcessor((Bitmap)resource.Value);
+                                byte[] subset = new byte[resourceData.Length - 4];
+                                Array.Copy(resourceData, 4, subset, 0, subset.Length);
+                                MemoryStream ms = new MemoryStream(subset);
+
+                                Bitmap recreatedBitmap = new Bitmap(ms);
+
+                                var bitmapProcessor = new nanoBitmapProcessor(recreatedBitmap);
                                 bitmapProcessor.Process(writer.GetMemoryBasedClone(stream));
                                 resourceData = stream.ToArray();
                             }
@@ -165,12 +172,23 @@ private static ResourceKind GetResourceKind(
                 return ResourceKind.String;
             }
 
-            if (resourceType.StartsWith("System.Drawing.Bitmap"))
+            // Check if the data is a bitmap, failure just means it is not.
+            try
             {
+                byte[] subset = new byte[resourceData.Length - 4];
+                Array.Copy(resourceData, 4,subset, 0,subset.Length);
+                MemoryStream ms = new MemoryStream(subset);
+
+                Bitmap bitmapImage = Image.FromStream(ms) as Bitmap;
                 return ResourceKind.Bitmap;
             }
+            catch
+            {
+                // Ignore error if not a bitmap
+            }
 
-            using(var stream = new MemoryStream(resourceData))
+            // None of the above, assume binary
+            using (var stream = new MemoryStream(resourceData))
             using (var reader = new BinaryReader(stream))
             {
                 var size = reader.ReadUInt32();

MetadataProcessor.Shared/Utility/nanoBitmapProcessor.cs

@@ -4,6 +4,7 @@
 // See LICENSE file in the project root for full license information.
 //
 
+using System;
 using System.Drawing;
 using System.Drawing.Imaging;
 
@@ -13,68 +14,99 @@ internal sealed class nanoBitmapProcessor
     {
         private readonly Bitmap _bitmap;
 
-        public nanoBitmapProcessor(
+        // Bitmap types supported by the native code found in "CLR_GFX_BitmapDescription"
+        private enum BitmapType
+        {
+            // Format of bitmap is 16-bit rgb565 format
+            nanoCLRBitmap = 0,
+            // Format of bitmap is GIF
+            Gif = 1,
+            // Format of bitmap JPEG
+            Jpeg = 2,
+            // Format of bitmap is Windows bitmap
+            // NOTE: There is support for compressed bitmaps in the native code, but the conversion of resources to Format16bppRgb565 
+            //       by the metadata processor eliminates this code being used.
+            WindowsBmp = 3,
+            // Not supported or unknown bitmap type
+            UnKnown = 255
+         }
+
+    public nanoBitmapProcessor(
             Bitmap bitmap)
         {
             _bitmap = bitmap;
         }
 
-        public void Process(
+        public void Process( 
             nanoBinaryWriter writer)
         {
+            // CLR_GFX_BitmapDescription header as required by the native side
             writer.WriteUInt32((uint)_bitmap.Width);
             writer.WriteUInt32((uint)_bitmap.Height);
 
             writer.WriteUInt16(0x00);   // flags
 
             var nanoImageFormat = GetnanoImageFormat(_bitmap.RawFormat);
 
+            // For GIF and JPEG, we do not convert
             if (nanoImageFormat != 0)
             {
-                writer.WriteByte(0x01);     // bpp
-                writer.WriteByte(nanoImageFormat);
+                writer.WriteByte(0x01);
+                writer.WriteByte((byte)nanoImageFormat);
                 _bitmap.Save(writer.BaseStream, _bitmap.RawFormat);
             }
             else
             {
-                writer.WriteByte(0x10);     // bpp
-                writer.WriteByte(nanoImageFormat);
+                byte bitsPerPixel = 16;
+                writer.WriteByte(bitsPerPixel);
+                writer.WriteByte((byte)nanoImageFormat);
 
-                var rect = new Rectangle(Point.Empty, _bitmap.Size);
-                using (var convertedBitmap =
-                    _bitmap.Clone(new Rectangle(Point.Empty, _bitmap.Size),
-                        PixelFormat.Format16bppRgb565))
+                try
                 {
-                    var bitmapData = convertedBitmap.LockBits(
-                        rect, ImageLockMode.ReadOnly, convertedBitmap.PixelFormat);
-
-                    var buffer = new short[bitmapData.Stride * convertedBitmap.Height / sizeof(short)];
-                    System.Runtime.InteropServices.Marshal.Copy(
-                        bitmapData.Scan0, buffer, 0, buffer.Length);
-
-                    convertedBitmap.UnlockBits(bitmapData);
-                    foreach (var item in buffer)
+                    Bitmap clone = new Bitmap(_bitmap.Width, _bitmap.Height, PixelFormat.Format16bppRgb565);
+                    using (Graphics gr = Graphics.FromImage(clone))
                     {
-                        writer.WriteInt16(item);
+                        gr.DrawImageUnscaled(_bitmap, 0, 0);
                     }
+
+                    Rectangle rect = new Rectangle(0, 0, clone.Width, clone.Height);
+                    BitmapData bitmapData = clone.LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format16bppRgb565);
+
+                    //  Format16bppRgb565 == 2 bytes per pixel
+                    byte[] data = new byte[clone.Width * clone.Height * 2];
+
+                    System.Runtime.InteropServices.Marshal.Copy(bitmapData.Scan0, data, 0, data.Length);
+                    clone.UnlockBits(bitmapData);
+                    writer.WriteBytes(data);
+
+                }
+                catch
+                {
+                    throw new NotSupportedException($"PixelFormat ({_bitmap.PixelFormat.ToString()}) could not be converted to Format16bppRgb565.");
                 }
             }
         }
 
-        private byte GetnanoImageFormat(
+        private BitmapType GetnanoImageFormat( 
             ImageFormat rawFormat)
         {
-            if (rawFormat.Equals(ImageFormat.Gif))
+            // Any windows bitmap format is marked for conversion to nanoCLRBitmap ( i.e. Format16bppRgb565 ) 
+            if (rawFormat.Equals(ImageFormat.Bmp))
             {
-                return 1;
+                return BitmapType.nanoCLRBitmap;
             }
-            
-            if (rawFormat.Equals(ImageFormat.Jpeg))
+            else if (rawFormat.Equals(ImageFormat.Gif))
             {
-                return 2;
+                return BitmapType.Gif;
+            }
+            else if (rawFormat.Equals(ImageFormat.Jpeg))
+            {
+                return BitmapType.Jpeg;
+            }
+            else
+            {
+                return BitmapType.UnKnown;
             }
-
-            return 0;
         }
     }
-}
+}

MetadataProcessor.Tests/Core/Utility/nanoBitmapProcessorTests.cs

@@ -11,12 +11,6 @@ namespace nanoFramework.Tools.MetadataProcessor.Tests.Core.Utility
     [TestClass]
     public class nanoBitmapProcessorTests
     {
-        [TestMethod]
-        public void ProcessBmpTest()
-        {
-            DoProcessTest("bmp.bmp", "bmp_expected_result.bin");
-        }
-
         [TestMethod]
         public void ProcessJpegTest()
         {