Refactor and optimize memory handling across SIPSorcery using Span APIs

Enhanced performance and memory efficiency throughout the SIPSorcery project by replacing traditional byte array handling with Span<byte> and ReadOnlySpan<byte> in multiple components, including RTCP, SCTP, and AudioEncoder classes.
Refactored packet parsing and serialization logic using BinaryPrimitives for endian conversions, and updated NetConvert accordingly.
Introduced utility methods in EncodingExtensions, TypeExtensions, BinaryOperations, and MemoryOperations to streamline string, byte array, and endian-aware operations.
Marked legacy methods as obsolete to guide migration to span-based APIs.
Updated SIPSorcery.csproj to include System.Memory and Microsoft.Bcl.HashCode packages, and enabled AllowUnsafeBlocks for performance-critical code paths.

Author: Paulo Morgado

.editorconfig

@@ -24,4 +24,22 @@ csharp_preserve_single_line_statements = true
 csharp_preserve_single_line_blocks = true
 
 # Don't allow single line if/else blocks without braces.
-csharp_prefer_braces = true:error 
+csharp_prefer_braces = true:error
+
+# IDE0007: Use implicit type
+dotnet_diagnostic.IDE0007.severity = suggestion
+
+# IDE0019: Use pattern matching
+dotnet_diagnostic.IDE0019.severity = suggestion
+
+# IDE0030: Use coalesce expression
+dotnet_diagnostic.IDE0030.severity = suggestion
+
+# IDE0031: Use null propagation
+dotnet_diagnostic.IDE0031.severity = suggestion
+
+# IDE0078: Use pattern matching
+dotnet_diagnostic.IDE0078.severity = suggestion
+
+# IDE0083: Use pattern matching
+dotnet_diagnostic.IDE0083.severity = suggestion

src/SIPSorcery.csproj

@@ -39,8 +39,9 @@
     <TargetFrameworks>netstandard2.0;netstandard2.1;netcoreapp3.1;net462;net5.0;net6.0;net8.0</TargetFrameworks>
     <LangVersion>12.0</LangVersion>
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
-    <NoWarn>$(NoWarn);SYSLIB0050</NoWarn>
+    <NoWarn>$(NoWarn);SYSLIB0050;CS1591;CS1573;CS1587</NoWarn>
     <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
+    <WarningsNotAsErrors>$(WarningsNotAsErrors);CS0809;CS0618;CS8632</WarningsNotAsErrors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <!-- Disable warning for missing XML doc comments. -->
     <NoWarn>$(NoWarn);CS1591;CS1573;CS1587</NoWarn>
@@ -93,6 +94,7 @@
     <IncludeSymbols>true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <ContinuousIntegrationBuild Condition="'$(CI)' == 'true'">true</ContinuousIntegrationBuild>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
 </Project>

src/app/Media/Codecs/AudioEncoder.cs

@@ -18,6 +18,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using SIPSorceryMedia.Abstractions;
+using SIPSorcery.Sys;
 using Concentus.Enums;
 
 namespace SIPSorcery.Media
@@ -121,16 +122,13 @@ public byte[] EncodeAudio(short[] pcm, AudioFormat format)
             }
             else if (format.Codec == AudioCodecsEnum.L16)
             {
-                // When netstandard2.1 can be used.
-                //return MemoryMarshal.Cast<short, byte>(pcm)
-
                 // Put on the wire in network byte order (big endian).
-                return pcm.SelectMany(x => new byte[] { (byte)(x >> 8), (byte)(x) }).ToArray();
+                return MemoryOperations.ToBigEndianBytes(pcm);
             }
             else if (format.Codec == AudioCodecsEnum.PCM_S16LE)
             {
                 // Put on the wire as little endian.
-                return pcm.SelectMany(x => new byte[] { (byte)(x), (byte)(x >> 8) }).ToArray();
+                return MemoryOperations.ToLittleEndianBytes(pcm);
             }
             else if (format.Codec == AudioCodecsEnum.OPUS)
             {
@@ -148,7 +146,7 @@ public byte[] EncodeAudio(short[] pcm, AudioFormat format)
 
                 byte[] encodedSample = new byte[pcm.Length];
                 int encodedLength = _opusEncoder.Encode(pcmFloat, pcmFloat.Length / format.ChannelCount, encodedSample, encodedSample.Length);
-                return encodedSample.Take(encodedLength).ToArray();
+                return encodedSample.AsSpan(0, encodedLength).ToArray();
             }
             else
             {
@@ -174,7 +172,7 @@ public short[] DecodeAudio(byte[] encodedSample, AudioFormat format)
                 short[] decodedPcm = new short[encodedSample.Length * 2];
                 int decodedSampleCount = _g722Decoder.Decode(_g722DecoderState, decodedPcm, encodedSample, encodedSample.Length);
 
-                return decodedPcm.Take(decodedSampleCount).ToArray();
+                return decodedPcm.AsSpan(0, decodedSampleCount).ToArray();
             }
             if (format.Codec == AudioCodecsEnum.G729)
             {

src/app/Media/Codecs/G729Encoder.cs

@@ -55,7 +55,7 @@ public class G729Encoder : Ld8k
          * Initialization of the coder.
          */
 
-        private byte[] _leftover = new byte[0];
+        private byte[] _leftover = Array.Empty<byte>();
 
         /**
          * Init the Ld8k Coder

src/core/SIP/Channels/SIPClientWebSocketChannel.cs

@@ -376,7 +376,7 @@ private void MonitorReceiveTasks()
                         if (receiveTask.IsCompleted)
                         {
                             logger.LogDebug("Client web socket connection to {ServerUri} received {BytesReceived} bytes.", conn.ServerUri, receiveTask.Result.Count);
-                            //SIPMessageReceived(this, conn.LocalEndPoint, conn.RemoteEndPoint, conn.ReceiveBuffer.Take(receiveTask.Result.Count).ToArray()).Wait();
+                            //SIPMessageReceived(this, conn.LocalEndPoint, conn.RemoteEndPoint, conn.ReceiveBuffer.AsSpan(0, receiveTask.Result.Count).ToArray()).Wait();
                             ExtractSIPMessages(this, conn, conn.ReceiveBuffer, receiveTask.Result.Count);
                             conn.ReceiveTask = conn.Client.ReceiveAsync(conn.ReceiveBuffer, m_cts.Token);
                         }

src/core/SIP/Channels/SIPWebSocketChannel.cs

@@ -122,7 +122,7 @@ protected override void OnError(ErrorEventArgs e)
 
             public void Send(byte[] buffer, int offset, int length)
             {
-                base.Send(buffer.Skip(offset).Take(length).ToArray());
+                base.Send(buffer.AsSpan(offset, length).ToArray());
             }
         }
 

src/net/DtlsSrtp/DtlsSrtpTransport.cs

@@ -18,6 +18,7 @@
 
 using System;
 using System.Collections.Concurrent;
+using System.ComponentModel;
 using Microsoft.Extensions.Logging;
 using Org.BouncyCastle.Tls;
 using SIPSorcery.Sys;
@@ -482,11 +483,15 @@ public int GetSendLimit()
             return this._sendLimit;
         }
 
-        public void WriteToRecvStream(byte[] buf)
+        [Obsolete("Use WriteToRecvStream(ReadOnlySpan<byte>) instead.", false)]
+        [EditorBrowsable(EditorBrowsableState.Advanced)]
+        public void WriteToRecvStream(byte[] buf) => WriteToRecvStream(buf.AsSpan());
+
+        public void WriteToRecvStream(ReadOnlySpan<byte> buf)
         {
             if (!_isClosed)
             {
-                _chunks.Add(buf);
+                _chunks.Add(buf.ToArray());
             }
         }
 

src/net/HEP/HepPacket.cs

@@ -316,7 +316,7 @@ public static byte[] GetBytes(SIPEndPoint srcEndPoint, SIPEndPoint dstEndPoint,
                 Buffer.BlockCopy(BitConverter.GetBytes((ushort)offset), 0, packetBuffer, 4, 2);
             }
 
-            return packetBuffer.Take(offset).ToArray();
+            return packetBuffer.AsSpan(0, offset).ToArray();
         }
     }
 }

src/net/ICE/RtpIceChannel.cs

@@ -904,7 +904,7 @@ public void AddRemoteCandidate(RTCIceCandidate candidate)
             {
                 OnIceCandidateError?.Invoke(candidate, $"Remote ICE candidate had an invalid port {candidate.port}.");
             }
-            else if(IPAddress.TryParse(candidate.address, out var addrIPv6) &&
+            else if (IPAddress.TryParse(candidate.address, out var addrIPv6) &&
                     addrIPv6.AddressFamily == AddressFamily.InterNetworkV6 &&
                     !Socket.OSSupportsIPv6 &&
                     NetServices.HasActiveIPv6Address())
@@ -1123,7 +1123,7 @@ private void CheckIceServers(Object state)
                 {
                     if (_activeIceServer == null || _activeIceServer.Error != SocketError.Success)
                     {
-                        if (_iceServerResolver.IceServers.Count(x => x.Value.Error == SocketError.Success) == 0)
+                        if (!_iceServerResolver.IceServers.Any(x => x.Value.Error == SocketError.Success))
                         {
                             logger.LogDebug("RTP ICE Channel all ICE server connection checks failed, stopping ICE servers timer.");
                             _processIceServersTimer.Dispose();
@@ -1136,7 +1136,7 @@ private void CheckIceServers(Object state)
                                 .OrderByDescending(x => x.Value._uri.Scheme) // TURN serves take priority.
                                 .FirstOrDefault();
 
-                            if (!entry.Equals(default(KeyValuePair<STUNUri, IceServer>)))
+                            if (entry.Key is not null && entry.Value is not null)
                             {
                                 _activeIceServer = entry.Value;
                             }
@@ -2168,7 +2168,7 @@ private ChecklistEntry GetChecklistEntryForStunResponse(byte[] transactionID)
         /// <returns>If found a matching state object or null if not.</returns>
         private IceServer GetIceServerForTransactionID(byte[] transactionID)
         {
-            if (_iceServerResolver.IceServers.Count() == 0)
+            if (_iceServerResolver.IceServers.Count == 0)
             {
                 return null;
             }
@@ -2180,7 +2180,7 @@ private IceServer GetIceServerForTransactionID(byte[] transactionID)
                            .Where(x => x.Value.IsTransactionIDMatch(txID))
                            .SingleOrDefault();
 
-                if (!entry.Equals(default(KeyValuePair<STUNUri, IceServer>)))
+                if (entry.Key is not null && entry.Value is not null)
                 {
                     return entry.Value;
                 }
@@ -2576,7 +2576,7 @@ private async Task<IPAddress[]> ResolveMdnsName(RTCIceCandidate candidate)
             {
                 if (MdnsResolve != null)
                 {
-                    logger.LogWarning("RTP ICE channel has both "+ nameof(MdnsGetAddresses) + " and " + nameof(MdnsGetAddresses) + " set. Only " + nameof(MdnsGetAddresses) + " will be used.");
+                    logger.LogWarning("RTP ICE channel has both " + nameof(MdnsGetAddresses) + " and " + nameof(MdnsGetAddresses) + " set. Only " + nameof(MdnsGetAddresses) + " will be used.");
                 }
                 return await MdnsGetAddresses(candidate.address).ConfigureAwait(false);
             }

src/net/RTCP/RTCPBye.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
 // Filename: RTCPBye.cs
 //
 // Description: RTCP Goodbye packet as defined in RFC3550.
@@ -27,6 +27,9 @@
 //-----------------------------------------------------------------------------
 
 using System;
+using System.Buffers.Binary;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Text;
 using SIPSorcery.Sys;
 
@@ -73,7 +76,17 @@ public RTCPBye(uint ssrc, string reason)
         /// Create a new RTCP Goodbye packet from a serialised byte array.
         /// </summary>
         /// <param name="packet">The byte array holding the Goodbye packet.</param>
-        public RTCPBye(byte[] packet)
+        [Obsolete("Use RTCPBye(ReadOnlySpan<byte> packet) instead.", false)]
+        [EditorBrowsable(EditorBrowsableState.Advanced)]
+        public RTCPBye(byte[] packet) : this(new ReadOnlySpan<byte>(packet))
+        {
+        }
+
+        /// <summary>
+        /// Create a new RTCP Goodbye packet from a serialised byte array.
+        /// </summary>
+        /// <param name="packet">The byte array holding the Goodbye packet.</param>
+        public RTCPBye(ReadOnlySpan<byte> packet)
         {
             if (packet.Length < MIN_PACKET_SIZE)
             {
@@ -82,56 +95,60 @@ public RTCPBye(byte[] packet)
 
             Header = new RTCPHeader(packet);
 
-            if (BitConverter.IsLittleEndian)
-            {
-                SSRC = NetConvert.DoReverseEndian(BitConverter.ToUInt32(packet, 4));
-            }
-            else
-            {
-                SSRC = BitConverter.ToUInt32(packet, 4);
-            }
+            SSRC = BinaryPrimitives.ReadUInt32BigEndian(packet.Slice(4));
 
             if (packet.Length > MIN_PACKET_SIZE)
             {
                 int reasonLength = packet[8];
 
                 if (packet.Length - MIN_PACKET_SIZE - 1 >= reasonLength)
                 {
-                    Reason = Encoding.UTF8.GetString(packet, 9, reasonLength);
+                    Reason = Encoding.UTF8.GetString(packet.Slice(9, reasonLength));
                 }
             }
         }
 
+        public int GetPacketSize() => RTCPHeader.HEADER_BYTES_LENGTH + GetPaddedLength(((Reason is not null) ? Encoding.UTF8.GetByteCount(Reason) : 0));
+
         /// <summary>
         /// Gets the raw bytes for the Goodbye packet.
         /// </summary>
         /// <returns>A byte array.</returns>
         public byte[] GetBytes()
         {
-            byte[] reasonBytes = (Reason != null) ? Encoding.UTF8.GetBytes(Reason) : null;
-            int reasonLength = (reasonBytes != null) ? reasonBytes.Length : 0;
-            byte[] buffer = new byte[RTCPHeader.HEADER_BYTES_LENGTH + GetPaddedLength(reasonLength)];
-            Header.SetLength((ushort)(buffer.Length / 4 - 1));
+            var buffer = new byte[GetPacketSize()];
 
-            Buffer.BlockCopy(Header.GetBytes(), 0, buffer, 0, RTCPHeader.HEADER_BYTES_LENGTH);
-            int payloadIndex = RTCPHeader.HEADER_BYTES_LENGTH;
+            WriteBytesCore(buffer);
 
-            if (BitConverter.IsLittleEndian)
-            {
-                Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(SSRC)), 0, buffer, payloadIndex, 4);
-            }
-            else
+            return buffer;
+        }
+
+        public int WriteBytes(Span<byte> buffer)
+        {
+            var size = GetPacketSize();
+
+            if (buffer.Length < size)
             {
-                Buffer.BlockCopy(BitConverter.GetBytes(SSRC), 0, buffer, payloadIndex, 4);
+                throw new ArgumentOutOfRangeException($"The buffer should have at least {size} bytes and had only {buffer.Length}.");
             }
 
-            if (reasonLength > 0)
+            WriteBytesCore(buffer.Slice(0, size));
+
+            return size;
+        }
+
+        private void WriteBytesCore(Span<byte> buffer)
+        {
+            Header.SetLength((ushort)(buffer.Length / 4 - 1));
+            _ = Header.WriteBytes(buffer);
+
+            BinaryPrimitives.WriteUInt32BigEndian(buffer.Slice(RTCPHeader.HEADER_BYTES_LENGTH), SSRC);
+
+            if (Reason is not null)
             {
-                buffer[payloadIndex + 4] = (byte)reasonLength;
-                Buffer.BlockCopy(reasonBytes, 0, buffer, payloadIndex + 5, reasonBytes.Length);
+                buffer[RTCPHeader.HEADER_BYTES_LENGTH + 4] =
+                    (byte)Encoding.UTF8.GetBytes(Reason.AsSpan(), buffer.Slice(RTCPHeader.HEADER_BYTES_LENGTH + 5));
             }
-
-            return buffer;
         }
 
         /// <summary>