Replace TryReadback API with Readback methods, remove Shutdown

Author: JimBobSquarePants

samples/DrawingBackendBenchmark/WebGpuBenchmarkBackend.cs

@@ -52,9 +52,17 @@ public BenchmarkRenderResult Render(ReadOnlySpan<VisualLine> lines, int width, i
 
         Image<Bgra32>? preview = null;
         string? readbackError = null;
-        if (capturePreview && !renderTarget.TryReadback(out preview, out readbackError))
+        if (capturePreview)
         {
-            preview = null;
+            try
+            {
+                preview = renderTarget.Readback();
+            }
+            catch (Exception ex)
+            {
+                preview = null;
+                readbackError = ex.Message;
+            }
         }
 
         return new BenchmarkRenderResult(

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.Readback.cs

@@ -62,14 +62,14 @@ public bool TryReadRegion<TPixel>(
             capability.Queue == 0 ||
             capability.TargetTexture == 0)
         {
-            error = "Readback is only available for native WebGPU targets with valid device, queue, and texture handles.";
+            error = "The target does not expose a native WebGPU surface with valid device, queue, and texture handles for readback.";
             return false;
         }
 
         if (!TryGetCompositeTextureFormat<TPixel>(out WebGPUTextureFormatId expectedFormat, out FeatureName requiredFeature) ||
             expectedFormat != capability.TargetFormat)
         {
-            error = $"Pixel type '{typeof(TPixel).Name}' is not compatible with target format '{capability.TargetFormat}'.";
+            error = $"Pixel type '{typeof(TPixel).Name}' cannot be read back from target format '{capability.TargetFormat}'.";
             return false;
         }
 
@@ -85,7 +85,7 @@ public bool TryReadRegion<TPixel>(
 
         if (source.Width <= 0 || source.Height <= 0)
         {
-            error = "The requested source rectangle does not intersect the target bounds.";
+            error = "The requested readback rectangle does not intersect the target bounds.";
             return false;
         }
 
@@ -96,7 +96,7 @@ public bool TryReadRegion<TPixel>(
         if (requiredFeature != FeatureName.Undefined
             && !WebGPURuntime.GetOrCreateDeviceState(api, device).HasFeature(requiredFeature))
         {
-            error = $"The target device does not support required feature '{requiredFeature}' for pixel type '{typeof(TPixel).Name}'.";
+            error = $"The target device does not support WebGPU feature '{requiredFeature}' required to read back pixel type '{typeof(TPixel).Name}'.";
             return false;
         }
 
@@ -124,15 +124,15 @@ public bool TryReadRegion<TPixel>(
             readbackBuffer = api.DeviceCreateBuffer(device, in bufferDescriptor);
             if (readbackBuffer is null)
             {
-                error = "WebGPU.DeviceCreateBuffer returned null for readback.";
+                error = "The WebGPU device could not create a readback buffer.";
                 return false;
             }
 
             CommandEncoderDescriptor encoderDescriptor = default;
             commandEncoder = api.DeviceCreateCommandEncoder(device, in encoderDescriptor);
             if (commandEncoder is null)
             {
-                error = "WebGPU.DeviceCreateCommandEncoder returned null.";
+                error = "The WebGPU device could not create a command encoder for readback.";
                 return false;
             }
 
@@ -163,7 +163,7 @@ public bool TryReadRegion<TPixel>(
             commandBuffer = api.CommandEncoderFinish(commandEncoder, in commandBufferDescriptor);
             if (commandBuffer is null)
             {
-                error = "WebGPU.CommandEncoderFinish returned null.";
+                error = "The WebGPU device could not finalize the readback command buffer.";
                 return false;
             }
 
@@ -187,15 +187,15 @@ void Callback(BufferMapAsyncStatus status, void* userData)
             api.BufferMapAsync(readbackBuffer, MapMode.Read, 0, (nuint)readbackByteCount, callback, null);
             if (!WaitForMapSignal(wgpuExtension, device, mapReady) || mapStatus != BufferMapAsyncStatus.Success)
             {
-                error = $"WebGPU readback map failed with status '{mapStatus}'.";
+                error = $"The WebGPU device could not map the readback buffer. Status: '{mapStatus}'.";
                 return false;
             }
 
             void* mapped = api.BufferGetConstMappedRange(readbackBuffer, 0, (nuint)readbackByteCount);
             if (mapped is null)
             {
                 api.BufferUnmap(readbackBuffer);
-                error = "WebGPU.BufferGetConstMappedRange returned null.";
+                error = "The WebGPU device mapped the readback buffer but returned no readable data.";
                 return false;
             }
 

src/ImageSharp.Drawing.WebGPU/WebGPURenderTarget{TPixel}.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Diagnostics.CodeAnalysis;
 using Silk.NET.WebGPU;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,7 +10,7 @@ namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 /// <summary>
 /// An offscreen WebGPU render target.
 /// Use this type when you want to render to a GPU-backed target and optionally read the result back with
-/// <see cref="TryReadback"/> or <see cref="TryReadbackInto(Image{TPixel}, out string?)"/>.
+/// <see cref="Readback"/> or <see cref="ReadbackInto(Image{TPixel})"/>.
 /// </summary>
 /// <typeparam name="TPixel">The canvas pixel format.</typeparam>
 public sealed class WebGPURenderTarget<TPixel> : IDisposable
@@ -185,52 +184,36 @@ public DrawingCanvas<TPixel> CreateCanvas(DrawingOptions options)
     }
 
     /// <summary>
-    /// Attempts to read the current GPU texture contents back into a new CPU image.
+    /// Reads the current GPU texture contents back into a new CPU image.
     /// </summary>
-    /// <param name="image">Receives the readback image on success.</param>
-    /// <param name="error">Receives the failure reason when readback cannot complete.</param>
-    /// <returns><see langword="true"/> when readback succeeds; otherwise <see langword="false"/>.</returns>
-    public bool TryReadback([NotNullWhen(true)] out Image<TPixel>? image, [NotNullWhen(false)] out string? error)
+    /// <returns>The readback image.</returns>
+    public Image<TPixel> Readback()
     {
-        if (this.isDisposed)
-        {
-            image = null;
-            error = "Render target is disposed.";
-            return false;
-        }
+        this.ThrowIfDisposed();
+        this.Graphics.ThrowIfDisposed();
 
+        Image<TPixel> image = new(this.Width, this.Height);
         try
         {
-            this.Graphics.ThrowIfDisposed();
-        }
-        catch (ObjectDisposedException ex)
-        {
-            image = null;
-            error = ex.Message;
-            return false;
+            this.ReadbackInto(image);
+            return image;
         }
-
-        image = new Image<TPixel>(this.Width, this.Height);
-        if (!this.TryReadbackInto(image, out error))
+        catch
         {
             image.Dispose();
-            image = null;
-            return false;
+            throw;
         }
-
-        error = null;
-        return true;
     }
 
     /// <summary>
-    /// Attempts to read the current GPU texture contents back into an existing CPU image.
+    /// Reads the current GPU texture contents back into an existing CPU image.
     /// </summary>
     /// <param name="destination">The destination image that receives the readback pixels.</param>
-    /// <param name="error">Receives the failure reason when readback cannot complete.</param>
-    /// <returns><see langword="true"/> when readback succeeds; otherwise <see langword="false"/>.</returns>
-    public bool TryReadbackInto(Image<TPixel> destination, [NotNullWhen(false)] out string? error)
+    public void ReadbackInto(Image<TPixel> destination)
     {
         Guard.NotNull(destination, nameof(destination));
+        this.ThrowIfDisposed();
+        this.Graphics.ThrowIfDisposed();
 
         if (destination.Width != this.Width || destination.Height != this.Height)
         {
@@ -239,35 +222,21 @@ public bool TryReadbackInto(Image<TPixel> destination, [NotNullWhen(false)] out
                 nameof(destination));
         }
 
-        if (this.isDisposed)
-        {
-            error = "Render target is disposed.";
-            return false;
-        }
-
-        try
-        {
-            this.Graphics.ThrowIfDisposed();
-        }
-        catch (ObjectDisposedException ex)
-        {
-            error = ex.Message;
-            return false;
-        }
-
         Buffer2DRegion<TPixel> region = new(destination.Frames.RootFrame.PixelBuffer, destination.Bounds);
         if (!this.Graphics.Backend.TryReadRegion(
                 this.Graphics.Configuration,
                 this.NativeFrame,
                 new Rectangle(0, 0, this.Width, this.Height),
                 region,
-                out error))
+                out string? error))
         {
-            return false;
-        }
+            if (error is null)
+            {
+                throw new InvalidOperationException("The WebGPU render target readback failed without reporting a reason.");
+            }
 
-        error = null;
-        return true;
+            throw new InvalidOperationException(error);
+        }
     }
 
     /// <summary>

src/ImageSharp.Drawing.WebGPU/WebGPURuntime.cs

@@ -20,12 +20,8 @@ namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 /// <see cref="TryGetOrCreateDevice"/> to use the cached default device/queue pair.
 /// </para>
 /// <para>
-/// Runtime unload is explicit:
+/// Runtime cleanup happens automatically on process exit.
 /// </para>
-/// <list type="bullet">
-/// <item><description><see cref="Shutdown"/> for explicit teardown.</description></item>
-/// <item><description>Best-effort cleanup on process exit.</description></item>
-/// </list>
 /// </remarks>
 internal static unsafe partial class WebGPURuntime
 {
@@ -366,21 +362,6 @@ internal static int ProbeComputePipelineSupport()
         }
     }
 
-    /// <summary>
-    /// Shuts down the process-level WebGPU runtime.
-    /// </summary>
-    /// <remarks>
-    /// This call is intended for coordinated application shutdown. Runtime state can be
-    /// reinitialized later by calling <see cref="GetApi"/> again.
-    /// </remarks>
-    public static void Shutdown()
-    {
-        lock (Sync)
-        {
-            DisposeRuntimeCore();
-        }
-    }
-
     /// <summary>
     /// Process-exit cleanup callback.
     /// </summary>
@@ -390,7 +371,11 @@ private static void OnProcessExit(object? sender, EventArgs e)
     {
         _ = sender;
         _ = e;
-        Shutdown();
+
+        lock (Sync)
+        {
+            DisposeRuntimeCore();
+        }
     }
 
     private static void DisposeRuntimeCore()
@@ -421,10 +406,35 @@ private static void DisposeRuntimeCore()
             computePipelineProbeError = null;
         }
 
-        wgpuExtension?.Dispose();
-        wgpuExtension = null;
-        api?.Dispose();
-        api = null;
+        // By the time process-exit teardown reaches the shared loader wrappers, the runtime may
+        // already be unwinding native loader state underneath Silk. The cached device/queue and
+        // all runtime-owned GPU state have already been released above, so these dispose failures
+        // no longer represent leaked WebGPU objects; they only mean the loader is already torn
+        // down or no longer in a state where Silk can unload it cleanly. We must still null the
+        // references so any later re-entry in the same process cannot observe stale wrappers.
+        try
+        {
+            wgpuExtension?.Dispose();
+        }
+        catch (Exception ex) when (ex is ObjectDisposedException or InvalidOperationException)
+        {
+        }
+        finally
+        {
+            wgpuExtension = null;
+        }
+
+        try
+        {
+            api?.Dispose();
+        }
+        catch (Exception ex) when (ex is ObjectDisposedException or InvalidOperationException)
+        {
+        }
+        finally
+        {
+            api = null;
+        }
     }
 
     private static void EnsureInitialized()

tests/ImageSharp.Drawing.Tests/Processing/FillParisTests.cs

@@ -63,8 +63,7 @@ public void FillParis_ImageSharp_WebGPU()
         }
 
         canvas.Flush();
-        Assert.True(target.TryReadback(out Image<Rgba32> readback, out string error), error);
-        using Image<Rgba32> readbackImage = readback!;
+        using Image<Rgba32> readbackImage = target.Readback();
         Assert.True(ContainsNonDefaultPixel(readbackImage));
     }