Cleanup DirectBitmap a bit more.

Author: Wayfarer

Imaging/DirectBitmapCore.cs

@@ -116,6 +116,49 @@ internal static void SetPixelsSimd(Pixel32[] bits, int width, int height, IEnume
             }
         }
 
+        /// <summary>
+        /// Sets pixels directly using unsafe pointer arithmetic for speed.
+        /// Updates both the WPF back buffer and the Pixel32 array.
+        /// </summary>
+        /// <param name="bits">The Pixel32 array.</param>
+        /// <param name="width">Width of the image.</param>
+        /// <param name="height">Height of the image.</param>
+        /// <param name="pixels">Pixels to set.</param>
+        /// <param name="backBuffer">Pointer to the back buffer (optional, for WPF WriteableBitmap).</param>
+        /// <param name="stride">Stride of the back buffer (required if backBuffer is not null).</param>
+        internal static unsafe void SetPixelsUnsafe(
+            Pixel32[] bits,
+            int width,
+            int height,
+            IEnumerable<PixelData> pixels,
+            byte* backBuffer = null,
+            int stride = 0)
+        {
+            if (bits == null || pixels == null) return;
+
+            if (backBuffer != null && stride <= 0)
+                throw new ArgumentException("Stride must be positive when backBuffer is provided.");
+
+            foreach (var pixel in pixels)
+            {
+                if ((uint)pixel.X >= width || (uint)pixel.Y >= height)
+                    continue;
+
+                // Update Pixel32 array
+                bits[pixel.Y * width + pixel.X] = new Pixel32(pixel.R, pixel.G, pixel.B, pixel.A);
+
+                // Update back buffer if provided
+                if (backBuffer != null)
+                {
+                    var offset = pixel.Y * stride + pixel.X * 4;
+                    backBuffer[offset + 0] = pixel.B;
+                    backBuffer[offset + 1] = pixel.G;
+                    backBuffer[offset + 2] = pixel.R;
+                    backBuffer[offset + 3] = pixel.A;
+                }
+            }
+        }
+
         /// <summary>
         /// Alpha blends another pixel buffer onto this image using SIMD.
         /// Format: BGRA (32-bit uint). Alpha is premultiplied at runtime.

Imaging/DirectBitmapImage.cs

@@ -161,38 +161,6 @@ public void SetPixel(int x, int y, Color color)
             }
         }
 
-        /// <summary>
-        ///     Sets pixels from a collection of <see cref="PixelData" />.
-        ///     Uses unsafe pointer arithmetic for speed.
-        /// </summary>
-        /// <param name="pixels">The pixels to set.</param>
-        public void SetPixelsUnsafe(IEnumerable<PixelData> pixels)
-        {
-            _bitmap.Lock();
-            unsafe
-            {
-                var buffer = (byte*)_bitmap.BackBuffer.ToPointer();
-                var stride = _bitmap.BackBufferStride;
-
-                foreach (var pixel in pixels)
-                {
-                    if ((uint)pixel.X >= Width || (uint)pixel.Y >= Height)
-                        continue;
-
-                    var offset = pixel.Y * stride + pixel.X * 4;
-                    buffer[offset + 0] = pixel.B;
-                    buffer[offset + 1] = pixel.G;
-                    buffer[offset + 2] = pixel.R;
-                    buffer[offset + 3] = pixel.A;
-
-                    // still update the shared Bits array
-                    DirectBitmapCore.SetPixels(Bits, Width, Height, new[] { pixel });
-                }
-            }
-            _bitmap.AddDirtyRect(new Int32Rect(0, 0, Width, Height));
-            _bitmap.Unlock();
-        }
-
         /// <summary>
         ///     Fills the bitmap with a uniform color using SIMD.
         /// </summary>
@@ -251,14 +219,54 @@ public void ApplyColorMatrix(float[][] matrix)
         /// Sets pixels from PixelData collection efficiently.
         /// </summary>
         /// <param name="pixels">Collection of PixelData (x, y, RGBA).</param>
-        public void SetPixels(IEnumerable<PixelData> pixels)
+        public void SetPixels(IEnumerable<PixelData> pixels, int threshold = 16)
         {
-            lock (_syncLock)
+            if (pixels == null) return;
+
+            IEnumerable<PixelData> pixelCollection = pixels;
+
+            // Materialize if not ICollection to count
+            int count;
+            if (pixels is ICollection<PixelData> col)
+            {
+                count = col.Count;
+            }
+            else
+            {
+                var list = pixels.ToList();
+                count = list.Count;
+                pixelCollection = list;
+            }
+
+            // Small batch -> unsafe direct write
+            if (count <= threshold)
             {
-                // Convert PixelData to (x, y, Pixel32)
-                var pixelData = pixels.Select(p => (p.X, p.Y, new Pixel32(p.R, p.G, p.B, p.A)));
+                if (_bitmap != null)
+                {
+                    _bitmap.Lock();
+                    unsafe
+                    {
+                        var buffer = (byte*)_bitmap.BackBuffer.ToPointer();
+                        var stride = _bitmap.BackBufferStride;
+                        DirectBitmapCore.SetPixelsUnsafe(Bits, Width, Height, pixelCollection, buffer, stride);
+                    }
+                    _bitmap.AddDirtyRect(new Int32Rect(0, 0, Width, Height));
+                    _bitmap.Unlock();
+                }
+                else
+                {
+                    unsafe
+                    {
+                        DirectBitmapCore.SetPixelsUnsafe(Bits, Width, Height, pixelCollection);
+                    }
+                }
+                return;
+            }
 
-                // SIMD batch update
+            // Large batch -> SIMD batch
+            lock (_syncLock)
+            {
+                var pixelData = pixelCollection.Select(p => (p.X, p.Y, new Pixel32(p.R, p.G, p.B, p.A)));
                 DirectBitmapCore.SetPixelsSimd(Bits, Width, Height, pixelData);
             }