Resolve issues within BitmapConverter (#41)

- Scanlines must be aligned on 32-bit boundaries (an address that's a multiple of 4).
- Swap the byte order also for images with an alpha channel (RGBA <-> BGRA).
- Apply the palette for Format8bppIndexed images.
- Ensure the image is casted to uchar before converting.

Author: kleisauke

samples/NetVips.Samples/Samples/GdiConvert.cs

@@ -1,20 +1,22 @@
 namespace NetVips.Samples
 {
     using Extensions;
+    using System.Drawing.Imaging;
 
     public class GdiConvert : ISample
     {
         public string Name => "GDI Convert";
         public string Category => "Utils";
 
-        public const string Filename = "images/equus_quagga.jpg";
+        public const string Filename = "images/PNG_transparency_demonstration_1.png";
 
         public string Execute(string[] args)
         {
             var image = Image.NewFromFile(Filename, access: Enums.Access.Sequential);
             var bitmap = image.ToBitmap();
+            bitmap.Save("vips-convert.png", ImageFormat.Png);
             var image2 = bitmap.ToVips();
-            image2.WriteToFile("gdi-convert.jpg");
+            image2.WriteToFile("gdi-convert.png");
 
             return "See gdi-convert.jpg";
         }

src/NetVips.Extensions/BitmapConverter.cs

@@ -85,32 +85,71 @@ public static Image ToVips(this Bitmap src)
 
             var bands = GuessBands(src.PixelFormat);
             var format = GuessBandFormat(src.PixelFormat);
+            var sizeofFormat = format == Enums.BandFormat.Uchar ? sizeof(byte) : sizeof(ushort);
 
             var w = src.Width;
             var h = src.Height;
+            var stride = w * bands * sizeofFormat;
+            var size = stride * h;
 
             var rect = new Rectangle(0, 0, w, h);
             BitmapData bd = null;
             Image dst;
             try
             {
                 bd = src.LockBits(rect, ImageLockMode.ReadOnly, src.PixelFormat);
-                dst = Image.NewFromMemoryCopy(bd.Scan0, (ulong)(bd.Stride * h), w, h, bands, format);
+
+                // bd.Stride is aligned to a multiple of 4
+                if (bd.Stride == stride)
+                {
+                    dst = Image.NewFromMemoryCopy(bd.Scan0, (ulong)size, w, h, bands, format);
+                }
+                else
+                {
+                    var buffer = new byte[size];
+
+                    // Copy the bytes from src to the managed array for each scanline
+                    for (var y = 0; y < h; y++)
+                    {
+                        Marshal.Copy(bd.Scan0 + y * bd.Stride, buffer, y * stride, stride);
+                    }
+
+                    dst = Image.NewFromMemory(buffer, w, h, bands, format);
+                }
             }
             finally
             {
                 if (bd != null)
                     src.UnlockBits(bd);
             }
 
-            if (bands != 3)
+            if (src.PixelFormat == PixelFormat.Format8bppIndexed)
             {
-                return dst;
+                var palette = new byte[256];
+                for (var i = 0; i < 256; i++)
+                {
+                    if (i >= src.Palette.Entries.Length)
+                        break;
+                    palette[i] = src.Palette.Entries[i].R;
+                }
+
+                var lut = Image.NewFromArray(palette);
+                return dst.Maplut(lut);
             }
 
-            // Switch from BGR to RGB
-            var images = dst.Bandsplit();
-            return images[2].Bandjoin(images[1], images[0]);
+            switch (bands)
+            {
+                case 3:
+                    // Switch from BGR to RGB
+                    var bgr = dst.Bandsplit();
+                    return bgr[2].Bandjoin(bgr[1], bgr[0]);
+                case 4:
+                    // Switch from BGRA to RGBA
+                    var bgra = dst.Bandsplit();
+                    return bgra[2].Bandjoin(bgra[1], bgra[0], bgra[3]);
+                default:
+                    return dst;
+            }
         }
 
         /// <summary>
@@ -123,6 +162,12 @@ public static Bitmap ToBitmap(this Image src)
             if (src == null)
                 throw new ArgumentNullException(nameof(src));
 
+            // Ensure image is casted to uint8 (unsigned char)
+            if (src.Bands < 3 || src.Format != Enums.BandFormat.Ushort)
+            {
+                src = src.Cast(Enums.BandFormat.Uchar);
+            }
+
             PixelFormat pf;
             switch (src.Bands)
             {
@@ -143,13 +188,17 @@ public static Bitmap ToBitmap(this Image src)
                         : PixelFormat.Format24bppRgb;
 
                     // Switch from RGB to BGR
-                    var bands = src.Bandsplit();
-                    src = bands[2].Bandjoin(bands[1], bands[0]);
+                    var rgb = src.Bandsplit();
+                    src = rgb[2].Bandjoin(rgb[1], rgb[0]);
                     break;
                 case 4:
                     pf = src.Format == Enums.BandFormat.Ushort
                         ? PixelFormat.Format64bppArgb
                         : PixelFormat.Format32bppArgb;
+
+                    // Switch from RGBA to BGRA
+                    var rgba = src.Bandsplit();
+                    src = rgba[2].Bandjoin(rgba[1], rgba[0], rgba[3]);
                     break;
                 default:
                     throw new NotImplementedException(
@@ -178,9 +227,35 @@ public static Bitmap ToBitmap(this Image src)
             try
             {
                 bd = dst.LockBits(rect, ImageLockMode.WriteOnly, pf);
+                var dstSize = (ulong)(bd.Stride * h);
+                var memory = src.WriteToMemory(out var srcSize);
+
+                // bd.Stride is aligned to a multiple of 4
+                if (dstSize == srcSize)
+                {
+                    unsafe
+                    {
+                        Buffer.MemoryCopy(memory.ToPointer(), bd.Scan0.ToPointer(), srcSize, srcSize);
+                    }
+                }
+                else
+                {
+                    var offset = w * src.Bands;
+
+                    // Copy the bytes from src to dst for each scanline
+                    for (var y = 0; y < h; y++)
+                    {
+                        var pSrc = memory + y * offset;
+                        var pDst = bd.Scan0 + y * bd.Stride;
+
+                        unsafe
+                        {
+                            Buffer.MemoryCopy(pSrc.ToPointer(), pDst.ToPointer(), offset, offset);
+                        }
+                    }
+                }
 
-                var memory = src.WriteToMemory();
-                Marshal.Copy(memory, 0, bd.Scan0, memory.Length);
+                NetVips.Free(memory);
             }
             finally
             {

src/NetVips.Extensions/NetVips.Extensions.csproj

@@ -19,6 +19,7 @@
     <AssemblyFileVersion>1.0.0.$(BuildNumber)</AssemblyFileVersion>
     <InformationalVersion>1.0.0.$(BuildNumber)$(PrereleaseLabel)</InformationalVersion>
     <PackageVersion>1.0.0.$(BuildNumber)$(PrereleaseLabel)</PackageVersion>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>

src/NetVips/Image.cs

@@ -599,7 +599,7 @@ public static Image NewFromArray<T>(T[] array, double scale = 1.0, double offset
         /// This method is useful for efficiently transferring images from GDI+
         /// into libvips.
         ///
-        /// See <see cref="WriteToMemory"/> for the opposite operation.
+        /// See <see cref="WriteToMemory()"/> for the opposite operation.
         ///
         /// Use <see cref="Copy"/> to set other image attributes.
         /// </remarks>
@@ -960,6 +960,26 @@ public void WriteToTarget(Target target, string formatString, VOption kwargs = n
         public void WriteToStream(Stream stream, string formatString, VOption kwargs = null) =>
             WriteToTarget(TargetStream.NewFromStream(stream), formatString, kwargs);
 
+        /// <summary>
+        /// Write the image to memory as a simple, unformatted C-style array.
+        /// </summary>
+        /// <remarks>
+        /// The caller is responsible for freeing this memory with <see cref="NetVips.Free"/>.
+        /// </remarks>
+        /// <param name="size">Output buffer length.</param>
+        /// <returns>A <see cref="IntPtr"/> pointing to an unformatted C-style array.</returns>
+        /// <exception cref="VipsException">If unable to write to memory.</exception>
+        public IntPtr WriteToMemory(out ulong size)
+        {
+            var pointer = VipsImage.WriteToMemory(this, out size);
+            if (pointer == IntPtr.Zero)
+            {
+                throw new VipsException("unable to write to memory");
+            }
+
+            return pointer;
+        }
+
         /// <summary>
         /// Write the image to a large memory array.
         /// </summary>
@@ -978,11 +998,7 @@ public void WriteToStream(Stream stream, string formatString, VOption kwargs = n
         /// <exception cref="VipsException">If unable to write to memory.</exception>
         public byte[] WriteToMemory()
         {
-            var pointer = VipsImage.WriteToMemory(this, out var size);
-            if (pointer == IntPtr.Zero)
-            {
-                throw new VipsException("unable to write to memory");
-            }
+            var pointer = WriteToMemory(out var size);
 
             var managedArray = new byte[size];
             Marshal.Copy(pointer, managedArray, 0, (int)size);

src/NetVips/NetVips.cs

@@ -400,5 +400,17 @@ public static IntPtr FundamentalType(IntPtr type)
         {
             return GType.Fundamental(type);
         }
+
+        /// <summary>
+        /// Frees the memory pointed to by <paramref name="mem"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is needed for <see cref="Image.WriteToMemory(out ulong)"/>.
+        /// </remarks>
+        /// <param name="mem">The memory to free.</param>
+        public static void Free(IntPtr mem)
+        {
+            GLib.GFree(mem);
+        }
     }
 }

tests/NetVips.Tests/ExtensionsTests.cs

@@ -86,8 +86,8 @@ private static void AssertPixelValue(byte[] expected, Bitmap actual)
             Marshal.Copy(bitmapData.Scan0, pixels, 0, expected.Length);
             actual.UnlockBits(bitmapData);
 
-            // Switch from BGR to RGB
-            if (expected.Length == 3)
+            // Switch from BGR(A) to RGB(A)
+            if (expected.Length > 2)
             {
                 var t = pixels[0];
                 pixels[0] = pixels[2];