Integrating ImageSharp with Windows and Uno Platform Applications

public partial class ImageSharpXamlCanvas : Canvas
{
    private const float DpiBase = 96.0f;

    private static readonly DependencyProperty ProxyVisibilityProperty =
        DependencyProperty.Register(
            "ProxyVisibility",
            typeof(Visibility),
            typeof(ImageSharpXamlCanvas),
            new PropertyMetadata(Visibility.Visible, OnVisibilityChanged));

    private static bool designMode = DesignMode.DesignModeEnabled;

    private bool ignorePixelScaling;
    private bool isVisible = true;

    // workaround for https://github.com/mono/SkiaSharp/issues/1118
    private int loadUnloadCounter = 0;

    private void Initialize()
    {
        if (designMode)
            return;

#if !WINDOWS
        var display = DisplayInformation.GetForCurrentView();
        OnDpiChanged(display);
#else
        Invalidate();
#endif

        Loaded += OnLoaded;
        Unloaded += OnUnloaded;
        SizeChanged += OnSizeChanged;

        var binding = new Binding
        {
            Path = new PropertyPath(nameof(Visibility)),
            Source = this
        };
        SetBinding(ProxyVisibilityProperty, binding);
    }

    public Size CanvasSize { get; private set; }

    public bool IgnorePixelScaling
    {
        get => ignorePixelScaling;
        set
        {
            ignorePixelScaling = value;
            Invalidate();
        }
    }

    public double Dpi { get; private set; } = 1;

    public event EventHandler<ImageSharpPaintSurfaceEventArgs> PaintSurface;

    protected virtual void OnPaintSurface(ImageSharpPaintSurfaceEventArgs e)
    {
        PaintSurface?.Invoke(this, e);
    }

    private static void OnVisibilityChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is ImageSharpXamlCanvas canvas && e.NewValue is Visibility visibility)
        {
            canvas.isVisible = visibility == Visibility.Visible;
            canvas.Invalidate();
        }
    }

    private void OnDpiChanged(DisplayInformation sender, object args = null)
    {
        Dpi = sender.LogicalDpi / DpiBase;
        Invalidate();
    }

    private void OnSizeChanged(object sender, SizeChangedEventArgs e)
    {
        Invalidate();
    }

    private void OnLoaded(object sender, RoutedEventArgs e)
    {
        loadUnloadCounter++;
        if (loadUnloadCounter != 1)
            return;

        DoLoaded();

#if !WINDOWS
        var display = DisplayInformation.GetForCurrentView();
        display.DpiChanged += OnDpiChanged;

        OnDpiChanged(display);
#else
        Invalidate();
#endif
    }

    private void OnUnloaded(object sender, RoutedEventArgs e)
    {
        loadUnloadCounter--;
        if (loadUnloadCounter != 0)
            return;

        DoUnloaded();

        var display = DisplayInformation.GetForCurrentView();
        display.DpiChanged -= OnDpiChanged;
    }

    public void Invalidate()
    {
        if (DispatcherQueue.HasThreadAccess)
            DoInvalidate();
        else
            DispatcherQueue.TryEnqueue(DoInvalidate);
    }

    partial void DoLoaded();

    partial void DoUnloaded();

    private Size CreateSize(out Size unscaledSize, out float dpi)
    {
        unscaledSize = Size.Empty;
        dpi = (float)Dpi;

        var w = ActualWidth;
        var h = ActualHeight;

        if (!IsPositive(w) || !IsPositive(h))
            return Size.Empty;

        unscaledSize = new Size((int)w, (int)h);
        return new Size((int)(w * dpi), (int)(h * dpi));

        static bool IsPositive(double value)
        {
            return !double.IsNaN(value) && !double.IsInfinity(value) && value > 0;
        }
    }

}

public partial class ImageSharpXamlCanvas : Canvas
{
    private byte[] pixels;
    private GCHandle pixelsHandle;
    private int pixelWidth;
    private int pixelHeight;
    private WriteableBitmap bitmap;

    public ImageSharpXamlCanvas()
    {
        Initialize();
    }

    partial void DoUnloaded() =>
        FreeBitmap();

    private void DoInvalidate()
    {
        if (designMode)
            return;

        if (!isVisible)
            return;

        if (ActualWidth <= 0 || ActualHeight <= 0)
        {
            CanvasSize = Size.Empty;
            return;
        }

        var info = CreateBitmap(out var unscaledSize, out var dpi);

        //using (var surface = SKSurface.Create(info, pixelsHandle.AddrOfPinnedObject(), info.RowBytes))
        using (var surface = new Image<Bgra32>(info.Width, info.Height)) // SKSurface.Create(info, pixelsHandle.AddrOfPinnedObject(), info.RowBytes))
        {
            var userVisibleSize = IgnorePixelScaling ? unscaledSize : info.Size;
            CanvasSize = userVisibleSize;

            //if (IgnorePixelScaling)
            //{
            //    var canvas = surface.Canvas;
            //    canvas.Scale(dpi);
            //    canvas.Save();
            //}

            OnPaintSurface(new ImageSharpPaintSurfaceEventArgs(surface, info with { Width = userVisibleSize.Width, Height = userVisibleSize.Height }, info));

            //surface.sa


            surface.CopyPixelDataTo(pixels);
        }



        // This implementation is not fast enough, and providing the original pixel buffer
        // is needed, yet the internal `IBufferByteAccess` interface is not yet available in Uno.
        // Once it is, we can replace this implementation and provide the pinned array directly
        // to skia.
        using (var data = bitmap.PixelBuffer.AsStream())
        {
            data.Write(pixels, 0, pixels.Length);
            data.Flush();
        }

        bitmap.Invalidate();
    }

    private ImageInfo CreateBitmap(out Size unscaledSize, out float dpi)
    {
        var size = CreateSize(out unscaledSize, out dpi);
        var info = new ImageInfo(size.Width, size.Height);//, SKImageInfo.PlatformColorType, SKAlphaType.Premul);

        if (bitmap?.PixelWidth != info.Width || bitmap?.PixelHeight != info.Height)
            FreeBitmap();

        if (bitmap == null && info.Width > 0 && info.Height > 0)
        {
            bitmap = new WriteableBitmap(info.Width, info.Height);

            var brush = new Microsoft.UI.Xaml.Media.ImageBrush
            {
                ImageSource = bitmap,
                AlignmentX = AlignmentX.Left,
                AlignmentY = AlignmentY.Top,
                Stretch = Stretch.Fill
            };

            Background = brush;
        }

        if (pixels == null || pixelWidth != info.Width || pixelHeight != info.Height)
        {
            FreeBitmap();

            pixels = new byte[info.BytesSize];
            pixelsHandle = GCHandle.Alloc(pixels, GCHandleType.Pinned);

            pixelWidth = info.Width;
            pixelHeight = info.Height;
        }

        return info;
    }

    private void FreeBitmap()
    {
        if (pixels != null)
        {
            pixelsHandle.Free();
            pixels = null;
            bitmap = null;
        }
    }
}


public class ImageSharpPaintSurfaceEventArgs : EventArgs
{
    public ImageSharpPaintSurfaceEventArgs(Image surface, ImageInfo info)
           : this(surface, info, info)
    {
    }

    public ImageSharpPaintSurfaceEventArgs(Image surface, ImageInfo info, ImageInfo rawInfo)
    {
        Surface = surface;
        Info = info;
        RawInfo = rawInfo;
    }

    public Image Surface { get; }

    public ImageInfo Info { get; }

    public ImageInfo RawInfo { get; }
}

public record ImageInfo(int Width, int Height)
{
    public int BytesSize => Width * Height * 4;// BytesPerPixel;
    public Size Size => new Size(Width, Height);
}