Honor MaxDegreeOfParallelism in flush

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/Backends/DefaultDrawingBackend.cs

@@ -36,7 +36,8 @@ public void FlushCompositions<TPixel>(
         using FlushScene scene = FlushScene.Create(
             compositionScene,
             target.Bounds,
-            configuration.MemoryAllocator);
+            configuration.MemoryAllocator,
+            configuration.MaxDegreeOfParallelism);
 
         if (scene.RowCount == 0)
         {
@@ -85,9 +86,15 @@ private static void ExecuteScene<TPixel>(
             }
         }
 
+        int requestedParallelism = configuration.MaxDegreeOfParallelism;
+        int partitionCount = Math.Min(
+            scene.RowCount,
+            requestedParallelism == -1 ? Environment.ProcessorCount : requestedParallelism);
+
         _ = Parallel.For(
             fromInclusive: 0,
             toExclusive: scene.RowCount,
+            parallelOptions: new ParallelOptions { MaxDegreeOfParallelism = partitionCount },
             localInit: () => new WorkerState<TPixel>(configuration.MemoryAllocator, destinationFrame.Width, scene.MaxLayerDepth + 1),
             body: (rowIndex, _, state) =>
             {

src/ImageSharp.Drawing/Processing/Backends/FlushScene.cs

@@ -119,11 +119,15 @@ private FlushScene(
     /// <param name="scene">The prepared composition scene.</param>
     /// <param name="targetBounds">The destination bounds of the flush.</param>
     /// <param name="allocator">The allocator used for retained row storage.</param>
+    /// <param name="maxDegreeOfParallelism">
+    /// The maximum degree of parallelism to use when building the scene, or -1 to use the default number of processors.
+    /// </param>
     /// <returns>A flush-ready scene.</returns>
     public static FlushScene Create(
         CompositionScene scene,
         in Rectangle targetBounds,
-        MemoryAllocator allocator)
+        MemoryAllocator allocator,
+        int maxDegreeOfParallelism)
     {
         int commandCount = scene.CommandCount;
 
@@ -145,12 +149,14 @@ public static FlushScene Create(
 
         FillSceneItem?[] fillItems = new FillSceneItem?[commandCount];
         StrokeSceneItem?[] strokeItems = new StrokeSceneItem?[commandCount];
-        int partitionCount = Math.Min(commandCount, Math.Min(Environment.ProcessorCount, targetRowCount));
+        int availableParallelism = maxDegreeOfParallelism == -1 ? Environment.ProcessorCount : maxDegreeOfParallelism;
+        int partitionCount = Math.Min(commandCount, Math.Min(availableParallelism, targetRowCount));
         PartitionState[] partitions = new PartitionState[partitionCount];
 
         _ = Parallel.For(
             0,
             partitionCount,
+            new ParallelOptions { MaxDegreeOfParallelism = partitionCount },
             partitionIndex =>
             {
                 // Integer division splits the commands into contiguous half-open ranges,