[OSX] Implemented IOSurface/MTLSharedEvent interop APIs

[kekekeks]

Added interop APIs for IOSurface/MTLSharedEvent.

MTLSharedEvent behaves differently to regular binary semaphores we've used previously, so new API for dealing with timeline semaphores was added (MoltenVK maps MTLSharedEvent to timeline semaphores and we are using Vulkan terminology anyway).

Public API additions:

class KnownPlatformGraphicsExternalImageHandleTypes
{
    /// <summary>
    /// A reference to IOSurface
    /// </summary>
    public const string IOSurfaceRef = nameof(IOSurfaceRef);
}


class KnownPlatformGraphicsExternalSemaphoreHandleTypes
    /// <summary>
    /// A pointer to MTLSharedEvent object
    /// </summary>
    public const string MetalSharedEvent = nameof(MetalSharedEvent);
}

class CompositionDrawingSurface
{

    /// <summary>
    /// Updates the surface contents using an imported memory image using a semaphore pair as the means of synchronization
    /// </summary>
    /// <param name="image">GPU image with new surface contents</param>
    /// <param name="waitForSemaphore">The semaphore to wait for before accessing the image</param>
    /// <param name="signalSemaphore">The semaphore to signal after accessing the image</param>
    /// <returns>A task that completes when update operation is completed and user code is free to destroy or dispose the image</returns>
    public Task UpdateWithTimelineSemaphoresAsync(ICompositionImportedGpuImage image,
        ICompositionImportedGpuSemaphore waitForSemaphore, ulong waitForValue,
        ICompositionImportedGpuSemaphore signalSemaphore, ulong signalValue)
    {
        var img = (CompositionImportedGpuImage)image;
        var wait = (CompositionImportedGpuSemaphore)waitForSemaphore;
        var signal = (CompositionImportedGpuSemaphore)signalSemaphore;
        return Compositor.InvokeServerJobAsync(() => Server.UpdateWithTimelineSemaphores(img, wait, waitForValue, signal, signalValue));
    }
}

enum CompositionGpuImportedImageSynchronizationCapabilities
    /// <summary>
    /// Pre-render and after-render timeline semaphores must be provided alongside with the image
    /// </summary>
    TimelineSemaphores = 8
}

Will address complaints about API "breaking changes" later today

[avaloniaui-bot]

You can test this PR using the following package version. 12.0.999-cibuild0056386-alpha. (feed url: https://nuget-feed-all.avaloniaui.net/v3/index.json) [PRBUILDID]

[maxkatz6]

Can you create an issue with brief API idea?

[kekekeks]

The general idea is to have an interface similar to ICompositionGpuInterop that's can be consumed from the render thread by CustomCompositionVisualHandler (and other API that we may add in the future). Instead of returning an asynchronously imported object the import operation would be completed immediately and will provide in some way a render-thread bitmap object suitable for consumption with ImmediateDrawingContext

[maxkatz6]

Why don't we read these properties (format, width, height) from the surface directly?

[kekekeks]

Those aren't always readable depending on the platform (it's an implementation of an xplat interface)

[maxkatz6]

This logic is not clear from the code. This handle feels like something to be disposed in the DisposeAsync method rather than here.

[kekekeks]

The idea of handle wrappers is to have something that extends the lifetime of the object passed to the import operation.

e. g. consider the following scenario:

1. a Metal API wrapper (such as MoltenVK) or a 3rd party rendering engine provides an API to access the backing resource (IOSurface/MtlTexture/etc), most notably this API does NOT increase the reference counter of said backing resource and user code has no means of manipulating such reference counter
2. Avalonia API is used to import such resource asynchronously
3. While operation is still pending the backing resource gets destroyed

So instead of sending the raw resource pointer/handle we instead use a handle wrapper that has internal knowledge of how to manipulate the reference counter, duplicate handle, etc. The wrapper is created immediately on the UI thread when Avalonia import API is called and then disposed on the render thread after the import operation

[maxkatz6]

GetRetainCountForNSObject doesn't seem to be used. And as per apple "This method is of no value in debugging memory management issues" (and in my observations, it's true, returned value often is unreliable)

[kekekeks]

and in my observations, it's true, returned value often is unreliable

It was very much usable while debugging this PR (I needed to observe when the value in fact changes), but we can delete it if you insist.

[maxkatz6]

LGTM

[MrJul]

This doesn't build, the SkiaMetalApi class is missing.
(It's used only for CreateBackendRenderTarget so it might be worth just having that method exposed instead.)

@kekekeks