Create ToWriteableBitmap() method similar to ToBitmapSource() to support Avalonia bitmap Images

[Ruben2776]

Is your feature request related to a problem? Please describe

No built-in bitmap conversion for AvaloniaUI, like WPF has.

Describe the solution you'd like

I would like to be able to convert a MagickImage to an Avalonia WriteableBitmap, with an easy extension method, just like WPF has.

Describe alternatives you've considered

I'm currently achieving it by setting the format as Png and writing it to a MemorySteam, but that is inefficient. I'm looking for a similar way of correctly converting the pixel data, to use for an Avalonia image.
I've tried doing it myself, but unfortunately I don't understand this well enough, as I've run into multiple issues such as ExecutionEngineException NullReferenceException etc.

Additional context

An example of rendering with WriteableBitmap in Avalonia: https://github.com/AvaloniaUI/Avalonia/blob/68a626f678b7fa4b1d1497cf7f419f7aebf703ee/samples/RenderDemo/Pages/WriteableBitmapPage.cs#L41
https://github.com/stevemonaco/AvaloniaDemos/tree/master/RealTimeBitmapAdapter
How to create Bitmap fron IntPtr
How to create a Bitmap from an image RGB buffer
AvaloniaUI/Avalonia#17365 (comment)

[dlemstra]

Marking this issue as an enhancement and hoping that someone will pick this up.

It looks like you will need to call Lock() on the WriteableBitmap and then write bytes to that memory address. You probably also need to check if RowBytes has padding per row. If you happen to get this working then please come back here with the solution.

[sefakpsz]

@Ruben2776 If Avalonia bitmap is not a must you can you SKBitmap instead of it.

[Ruben2776]

@sefakpsz Thanks, but I need to use Magick.NET for displaying formats such as .jxl, .avif, .psd, RAW camera files etc., which Skia has no support for.

[jdmsolarius]

Here is the approach I would take. It's very similar to what I use, basically we get a buffer, we pin the buffer in memory, and then we convert. I am assuming Avalonia Bitmaps are 8 bit? If they aren't this code gets much easier but here is how I would do it. If you can tell me more about your specific case I can help better. This doesn't have to be Parallel it'll be very fast without Parallel but even faster with it. Don't call ImageMagick .ToByteArray, that will significantly slow down the function just point to the UnsafePixels. The Pixel Packing is optional usually the JIT will optimize but I keep it around for older versions.

``

public static unsafe Bitmap ToBitmapFast<TQuantumType>(this IMagickImage<TQuantumType> self, Avalonia.Media.Imaging.Bitmap bitmap)
where TQuantumType : struct, IConvertible
{

IMagickImage<TQuantumType> image = self;
    
// Determine the pixel format based on whether the image has alpha
PixelFormat format = self.HasAlpha ? PixelFormat.Format32bppArgb : PixelFormat.Format24bppRgb;

int height = image.Height;
int width = image.Width;
using IUnsafePixelCollection<TQuantumType> pixels = image.GetPixelsUnsafe();

// Create a buffer to store the pixel data
byte[] buffer = new byte[width * height * 4]; // Assuming 4 bytes per pixel (RGBA)

// Pin the buffer to get a pointer to the unmanaged memory location
GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
nint bufferPtr = (nint)handle.AddrOfPinnedObject();

// Use CopyPixels to copy data to the buffer
bitmap.CopyPixels(new PixelRect(0, 0, width, height), bufferPtr, buffer.Length, width * 4);

// After using the data, be sure to free the pinned handle
handle.Free();

try
{
    // Get the source pointer for the entire image
    nint pointer = pixels.GetAreaPointer(0, 0, width, height);

    ushort* srcPtr = (ushort*)pointer; // Source is ushort (for grayscale or other formats)
    byte* destPtr = (byte*)bufferPtr; // Destination is byte array

    int destinationStride = width * 4; // Stride for RGBA format
    int channels = image.ChannelCount;

    // Process each row of pixels
    for (int row = 0; row < height; row++)
    {
        ushort* srcRowPtr = srcPtr + row * width; // Pointer to current row in source image
        byte* destRowPtr = destPtr + row * destinationStride; // Pointer to current row in destination buffer

        if (channels == 1) // Grayscale
        {
            for (int col = 0; col < width; col++)
            {
                ushort pixelValue = srcRowPtr[col];
                byte normalizedValue = (byte)(pixelValue >> 8);

                // Pack RGB (grayscale) pixels into 32-bit integer
                int packedPixel = normalizedValue << 16 | normalizedValue << 8 | normalizedValue;
                *(int*)(destRowPtr + col * 4) = packedPixel; // Write to destination buffer
            }
        }
        else if (channels == 3) // RGB (no alpha)
        {
            for (int col = 0; col < width; col++)
            {
                byte pixelValueB = (byte)(srcRowPtr[col * 3] >> 8);
                byte pixelValueG = (byte)(srcRowPtr[col * 3 + 1] >> 8);
                byte pixelValueR = (byte)(srcRowPtr[col * 3 + 2] >> 8);

                // Pack RGB pixels into 32-bit integer
                int packedPixel = pixelValueB << 16 | pixelValueG << 8 | pixelValueR;
                *(int*)(destRowPtr + col * 4) = packedPixel; // Write to destination buffer
            }
        }
        else // RGBA (with alpha)
        {
            for (int col = 0; col < width; col++)
            {
                byte pixelValueB = (byte)(srcRowPtr[col * 4] >> 8);
                byte pixelValueG = (byte)(srcRowPtr[col * 4 + 1] >> 8);
                byte pixelValueR = (byte)(srcRowPtr[col * 4 + 2] >> 8);
                byte pixelValueA = (byte)(srcRowPtr[col * 4 + 3] >> 8);

                // Pack RGBA pixels into 32-bit integer
                int packedPixel = pixelValueA << 24 | pixelValueB << 16 | pixelValueG << 8 | pixelValueR;
                *(int*)(destRowPtr + col * 4) = packedPixel; // Write to destination buffer
            }
        }
    }
}
finally
{
    // Cleanup
}

return bitmap;

``}

[dlemstra]

An initial version has been published (Magick.NET.AvaloniaMediaImaging). Performance improvements might follow in the future. I don't know when I have time to check @jdmsolarius their suggestions and run some benchmarks for this.