Add benchmarks for PixelConverter

Added PixelConverterBenchmarks under benchmarks/SIPSorceryMedia.Abstractions with .csproj and solution registration. Implemented multiple BenchmarkDotNet classes for pixel format conversions (I420, NV12, BGR, BGRA) with array and buffer writer variants. Introduced custom BenchmarkDotNet config (Config.cs) for job setup and output. Added Utils.cs for bitmap-to-buffer and odd-dimension buffer helpers. Included Program.cs to run benchmarks, global.json for .NET SDK pinning, and ensured test images copy to output. Updated solution structure accordingly.

Author: paulomorgado

SIPSorcery.slnx

@@ -21,6 +21,10 @@
     <Project Path="test/unit/SIPSorcery.UnitTests.csproj" />
     <Project Path="test/VideoCaptureTest/VideoCaptureTest.csproj" />
   </Folder>
+  <Folder Name="/benchmarks/" />
+  <Folder Name="/benchmarks/SIPSorceryMedia.Abstractions/">
+    <Project Path="benchmarks/SIPSorceryMedia.Abstractions/PixelConverterBenchmarks/PixelConverterBenchmarks.csproj" />
+  </Folder>
   <Folder Name="/examples/">
     <Project Path="examples/sipcmdline/sipcmdline.csproj" />
     <Project Path="examples/StunServer/StunServer.csproj" />

benchmarks/SIPSorceryMedia.Abstractions/PixelConverterBenchmarks/Config.cs

@@ -0,0 +1,93 @@
+using System.Collections.Immutable;
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.Filters;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Order;
+using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Running;
+
+#nullable disable
+
+namespace PixelConverterBenchmarks;
+
+internal sealed class Config : ManualConfig
+{
+    private const string _currentJobId = "Current";
+
+    public Config()
+    {
+        Runtime[] targetRuntimes = [CoreRuntime.Core10_0];
+        string[] targetVersions = ["10.0.15", ""];
+
+        foreach (var version in targetVersions)
+        {
+            var isBaseline = string.Equals(version, targetVersions[0]);
+
+            foreach (var targetRuntime in targetRuntimes)
+            {
+                AddJob(Job.MediumRun
+                    .WithRuntime(targetRuntime)
+                    .WithMsBuildArguments($"/p:LibVersion={version}")
+                    .WithId(isBaseline ? version : _currentJobId)
+                    .WithBaseline(isBaseline)
+                );
+            }
+        }
+
+        AddFilter(new SimpleFilter(static benchmark =>
+        {
+            var isBufferWriter = benchmark.Descriptor.WorkloadMethod.Name.EndsWith("BufferWriter", StringComparison.Ordinal);
+
+            var isBaselineJob = string.Equals(_currentJobId, benchmark.Job.Id, StringComparison.Ordinal);
+
+            return !isBufferWriter || isBaselineJob;
+        }));
+
+        WithOrderer(new RuntimeGroupedOrderer());
+
+        AddExporter(BenchmarkDotNet.Exporters.MarkdownExporter.GitHub);
+
+        AddColumnProvider(BenchmarkDotNet.Columns.DefaultColumnProviders.Instance);
+        HideColumns(Column.Arguments, Column.Error, Column.Median, Column.StdDev, Column.RatioSD);
+
+        WithSummaryStyle(SummaryStyle.Default.WithMaxParameterColumnWidth(int.MaxValue));
+
+        AddDiagnoser(BenchmarkDotNet.Diagnosers.MemoryDiagnoser.Default);
+
+        AddLogger(BenchmarkDotNet.Loggers.ConsoleLogger.Default);
+    }
+
+    private sealed class RuntimeGroupedOrderer : IOrderer
+    {
+        public IEnumerable<BenchmarkCase> GetExecutionOrder(
+            ImmutableArray<BenchmarkCase> benchmarksCase,
+            IEnumerable<BenchmarkLogicalGroupRule> order = null)
+            => benchmarksCase;
+
+        public IEnumerable<BenchmarkCase> GetSummaryOrder(
+            ImmutableArray<BenchmarkCase> benchmarksCases,
+            Summary summary)
+            => benchmarksCases
+                .OrderBy(b => b.Job.Environment.Runtime?.Name)
+                .ThenBy(b => b.Descriptor.WorkloadMethod.Name)
+                .ThenBy(b => b.Job.Id == _currentJobId ? 0 : 1)
+                .ThenByDescending(b => b.Job.Id);
+
+        public string GetHighlightGroupKey(BenchmarkCase benchmarkCase)
+            => benchmarkCase.Job.Environment.Runtime?.Name;
+
+        public string GetLogicalGroupKey(
+            ImmutableArray<BenchmarkCase> allBenchmarksCases,
+            BenchmarkCase benchmarkCase)
+            => benchmarkCase.Job.Environment.Runtime?.Name;
+
+        public IEnumerable<IGrouping<string, BenchmarkCase>> GetLogicalGroupOrder(
+            IEnumerable<IGrouping<string, BenchmarkCase>> logicalGroups,
+            IEnumerable<BenchmarkLogicalGroupRule> order = null)
+            => logicalGroups.OrderBy(g => g.Key);
+
+        public bool SeparateLogicalGroups => true;
+    }
+}

benchmarks/SIPSorceryMedia.Abstractions/PixelConverterBenchmarks/ConvertI420ToNV12Benchmarks.cs

@@ -0,0 +1,51 @@
+using System.Diagnostics;
+using BenchmarkDotNet.Attributes;
+using SIPSorceryMedia.Abstractions;
+
+namespace PixelConverterBenchmarks;
+
+public class ConvertI420ToNV12Benchmarks
+{
+#if !LibVersion
+    CommunityToolkit.HighPerformance.Buffers.ArrayPoolBufferWriter<byte>? _nv12Writer = new();
+#endif
+    private byte[]? _i420;
+    private const int Width = 640;
+    private const int Height = 480;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _i420 = File.ReadAllBytes("img/ref-i420.yuv");
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+#if !LibVersion
+        Debug.Assert(_nv12Writer is not null);
+        _nv12Writer.Clear();
+#endif
+    }
+
+    [Benchmark]
+    public int ConvertI420ToNV12Array()
+    {
+        Debug.Assert(_i420 is not null);
+        var nv12 = PixelConverter.I420toNV12(_i420, Width, Height);
+        return nv12.Length;
+    }
+
+    [Benchmark]
+    public int ConvertI420ToNV12BufferWriter()
+    {
+#if LibVersion
+        return 0;
+#else
+        Debug.Assert(_i420 is not null);
+        Debug.Assert(_nv12Writer is not null);
+        PixelConverter.I420toNV12(_nv12Writer, _i420.AsSpan(), Width, Height);
+        return _nv12Writer.WrittenCount;
+#endif
+    }
+}

benchmarks/SIPSorceryMedia.Abstractions/PixelConverterBenchmarks/ConvertKnownI420ToBGRBenchmarks.cs

@@ -0,0 +1,51 @@
+using System.Diagnostics;
+using BenchmarkDotNet.Attributes;
+using SIPSorceryMedia.Abstractions;
+
+namespace PixelConverterBenchmarks;
+
+public class ConvertKnownI420ToBGRBenchmarks
+{
+#if !LibVersion
+    CommunityToolkit.HighPerformance.Buffers.ArrayPoolBufferWriter<byte>? _bgrWriter = new();
+#endif
+    private byte[]? _i420;
+    private int _width = 640;
+    private int _height = 480;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _i420 = File.ReadAllBytes("img/ref-i420.yuv");
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+#if !LibVersion
+        Debug.Assert(_bgrWriter is not null);
+        _bgrWriter.Clear();
+#endif
+    }
+
+    [Benchmark]
+    public int RoundtripBgr24ToI420Array()
+    {
+        Debug.Assert(_i420 is not null);
+        var bgr = PixelConverter.I420toBGR(_i420, _width, _height, out _);
+        return bgr.Length;
+    }
+
+    [Benchmark]
+    public int RoundtripBgr24ToI420BufferWriter()
+    {
+#if LibVersion
+        return 0;
+#else
+        Debug.Assert(_i420 is not null);
+        Debug.Assert(_bgrWriter is not null);
+        PixelConverter.I420toBGR(_bgrWriter, _i420, _width, _height, out _);
+        return _bgrWriter.WrittenCount;
+#endif
+    }
+}

benchmarks/SIPSorceryMedia.Abstractions/PixelConverterBenchmarks/ConvertKnownNV12ToBGRBenchmarks.cs

@@ -0,0 +1,53 @@
+using System.Diagnostics;
+using BenchmarkDotNet.Attributes;
+using SIPSorceryMedia.Abstractions;
+
+namespace PixelConverterBenchmarks;
+
+public class ConvertKnownNV12ToBGRBenchmarks
+{
+#if !LibVersion
+    CommunityToolkit.HighPerformance.Buffers.ArrayPoolBufferWriter<byte>? _bgrWriter = new();
+#endif
+    private byte[]? _nv12;
+    private int _width = 640;
+    private int _height = 480;
+    private int _stride;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _nv12 = File.ReadAllBytes("img/ref-nv12.yuv");
+        _stride = _width * 3;
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+#if !LibVersion
+        Debug.Assert(_bgrWriter is not null);
+        _bgrWriter.Clear();
+#endif
+    }
+
+    [Benchmark]
+    public int RoundtripBgr24ToI420Array()
+    {
+        Debug.Assert(_nv12 is not null);
+        var bgr = PixelConverter.NV12toBGR(_nv12, _width, _height, _stride);
+        return bgr.Length;
+    }
+
+    [Benchmark]
+    public int RoundtripBgr24ToI420BufferWriter()
+    {
+#if LibVersion
+        return 0;
+#else
+        Debug.Assert(_nv12 is not null);
+        Debug.Assert(_bgrWriter is not null);
+        PixelConverter.NV12toBGR(_bgrWriter, _nv12, _width, _height, _stride);
+        return _bgrWriter.WrittenCount;
+#endif
+    }
+}

benchmarks/SIPSorceryMedia.Abstractions/PixelConverterBenchmarks/ConvertOddDimensionI420ToNV12Benchmarks.cs

@@ -0,0 +1,52 @@
+using System.Diagnostics;
+using BenchmarkDotNet.Attributes;
+using SIPSorceryMedia.Abstractions;
+
+namespace PixelConverterBenchmarks;
+
+public class ConvertOddDimensionI420ToNV12Benchmarks
+{
+#if !LibVersion
+    CommunityToolkit.HighPerformance.Buffers.ArrayPoolBufferWriter<byte>? _nv12Writer = new();
+#endif
+    private byte[]? _oddI420;
+    private const int OddWidth = 5;
+    private const int OddHeight = 3;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        var i420 = File.ReadAllBytes("img/ref-i420.yuv");
+        _oddI420 = Utils.CreateOddDimensionBuffer(OddWidth, OddHeight);
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+#if !LibVersion
+        Debug.Assert(_nv12Writer is not null);
+        _nv12Writer.Clear();
+#endif
+    }
+
+    [Benchmark]
+    public int ConvertOddDimensionI420ToNV12Array()
+    {
+        Debug.Assert(_oddI420 is not null);
+        var nv12 = PixelConverter.I420toNV12(_oddI420, OddWidth, OddHeight);
+        return nv12.Length;
+    }
+
+    [Benchmark]
+    public int ConvertOddDimensionI420ToNV12BufferWriter()
+    {
+#if LibVersion
+        return 0;
+#else
+        Debug.Assert(_nv12Writer is not null);
+        Debug.Assert(_oddI420 is not null);
+        PixelConverter.I420toNV12(_nv12Writer, _oddI420.AsSpan(), OddWidth, OddHeight);
+        return _nv12Writer.WrittenCount;
+#endif
+    }
+}

benchmarks/SIPSorceryMedia.Abstractions/PixelConverterBenchmarks/ConvertOddDimensionNV12ToI420Banchmarks.cs

@@ -0,0 +1,51 @@
+using System.Diagnostics;
+using BenchmarkDotNet.Attributes;
+using SIPSorceryMedia.Abstractions;
+
+namespace PixelConverterBenchmarks;
+
+public class ConvertOddDimensionNV12ToI420Banchmarks
+{
+#if !LibVersion
+    CommunityToolkit.HighPerformance.Buffers.ArrayPoolBufferWriter<byte>? _i420Writer = new();
+#endif
+    private byte[]? _oddNv12;
+    private const int OddWidth = 5;
+    private const int OddHeight = 3;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _oddNv12 = Utils.CreateOddDimensionBuffer(OddWidth, OddHeight);
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+#if !LibVersion
+        Debug.Assert(_i420Writer is not null);
+        _i420Writer.Clear();
+#endif
+    }
+
+    [Benchmark]
+    public int ConvertOddDimensionNV12ToI420Array()
+    {
+        Debug.Assert(_oddNv12 is not null);
+        var i420 = PixelConverter.NV12toI420(_oddNv12, OddWidth, OddHeight);
+        return i420.Length;
+    }
+
+    [Benchmark]
+    public int ConvertOddDimensionNV12ToI420BufferWriter()
+    {
+#if LibVersion
+        return 0;
+#else
+        Debug.Assert(_i420Writer is not null);
+        Debug.Assert(_oddNv12 is not null);
+        PixelConverter.NV12toI420(_i420Writer, _oddNv12.AsSpan(), OddWidth, OddHeight);
+        return _i420Writer.WrittenCount;
+#endif
+    }
+}