Remove allocations and cleanup.

Author: JimBobSquarePants

src/ImageSharp/Formats/Jpeg/JpegComData.cs

@@ -1,32 +1,32 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.Formats.Jpeg;
 
 /// <summary>
-/// Contains JPEG comment
+/// Represents a JPEG comment
 /// </summary>
 public readonly struct JpegComData
 {
-    /// <summary>
-    /// Converts string to <see cref="JpegComData"/>
-    /// </summary>
-    /// <param name="value">The comment string.</param>
-    /// <returns>The <see cref="JpegComData"/></returns>
-    public static JpegComData FromString(string value) => new(value.AsMemory());
-
     /// <summary>
     /// Initializes a new instance of the <see cref="JpegComData"/> struct.
     /// </summary>
-    /// <param name="value">The comment ReadOnlyMemory of chars.</param>
+    /// <param name="value">The comment buffer.</param>
     public JpegComData(ReadOnlyMemory<char> value)
         => this.Value = value;
 
+    /// <summary>
+    /// Gets the value.
+    /// </summary>
     public ReadOnlyMemory<char> Value { get; }
 
     /// <summary>
-    /// Converts Value to string
+    /// Converts string to <see cref="JpegComData"/>
     /// </summary>
-    /// <returns>The comment string.</returns>
+    /// <param name="value">The comment string.</param>
+    /// <returns>The <see cref="JpegComData"/></returns>
+    public static JpegComData FromString(string value) => new(value.AsMemory());
+
+    /// <inheritdoc/>
     public override string ToString() => this.Value.ToString();
 }

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -6,7 +6,6 @@
 using System.Buffers.Binary;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Text;
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
@@ -481,6 +480,8 @@ internal void ParseStream(BufferedReadStream stream, SpectralConverter spectralC
                         break;
 
                     case JpegConstants.Markers.APP15:
+                        stream.Skip(markerContentByteSize);
+                        break;
                     case JpegConstants.Markers.COM:
                         this.ProcessComMarker(stream, markerContentByteSize);
                         break;
@@ -523,16 +524,16 @@ public void Dispose()
     /// <param name="markerContentByteSize">The remaining bytes in the segment block.</param>
     private void ProcessComMarker(BufferedReadStream stream, int markerContentByteSize)
     {
-        char[] temp = new char[markerContentByteSize];
+        char[] chars = new char[markerContentByteSize];
         JpegMetadata metadata = this.Metadata.GetFormatMetadata(JpegFormat.Instance);
 
         for (int i = 0; i < markerContentByteSize; i++)
         {
             int read = stream.ReadByte();
-            temp[i] = (char)read;
+            chars[i] = (char)read;
         }
 
-        metadata.Comments.Add(new JpegComData(temp));
+        metadata.Comments.Add(new JpegComData(chars));
     }
 
     /// <summary>

src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs

@@ -2,9 +2,8 @@
 // Licensed under the Six Labors Split License.
 #nullable disable
 
+using System.Buffers;
 using System.Buffers.Binary;
-using System.Collections;
-using System.Text;
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder;
@@ -27,6 +26,9 @@ internal sealed unsafe partial class JpegEncoderCore : IImageEncoderInternals
     /// </summary>
     private static readonly JpegFrameConfig[] FrameConfigs = CreateFrameConfigs();
 
+    /// <summary>
+    /// The current calling encoder.
+    /// </summary>
     private readonly JpegEncoder encoder;
 
     /// <summary>
@@ -92,7 +94,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
         this.WriteProfiles(metadata, buffer);
 
         // Write comments
-        this.WriteComment(jpegMetadata);
+        this.WriteComments(image.Configuration, jpegMetadata);
 
         // Write the image dimensions.
         this.WriteStartOfFrame(image.Width, image.Height, frameConfig, buffer);
@@ -173,67 +175,48 @@ private void WriteJfifApplicationHeader(ImageMetadata meta, Span<byte> buffer)
     }
 
     /// <summary>
-    /// Writes comment
+    /// Writes the COM tags.
     /// </summary>
+    /// <param name="configuration">The configuration.</param>
     /// <param name="metadata">The image metadata.</param>
-    private void WriteComment(JpegMetadata metadata)
+    private void WriteComments(Configuration configuration, JpegMetadata metadata)
     {
-        int maxCommentLength = 65533;
-
         if (metadata.Comments.Count == 0)
         {
             return;
         }
 
-        // We don't want to modify original metadata
-        List<JpegComData> comments = new(metadata.Comments);
-
-        int totalPayloadLength = 0;
-        for (int i = 0; i < comments.Count; i++)
+        const int maxCommentLength = 65533;
+        using IMemoryOwner<byte> bufferOwner = configuration.MemoryAllocator.Allocate<byte>(maxCommentLength);
+        Span<byte> buffer = bufferOwner.Memory.Span;
+        foreach (JpegComData comment in metadata.Comments)
         {
-            JpegComData comment = comments[i];
-            ReadOnlyMemory<char> currentComment = comment.Value;
-
-            if (comment.Value.Length > maxCommentLength)
+            int totalLength = comment.Value.Length;
+            if (totalLength == 0)
             {
-                ReadOnlyMemory<char> splitComment =
-                    currentComment.Slice(maxCommentLength, currentComment.Length - maxCommentLength);
-                comments.Insert(i + 1, new JpegComData(splitComment));
-
-                // We don't want to keep the extra bytes
-                comments[i] = new JpegComData(currentComment.Slice(0, maxCommentLength));
+                continue;
             }
 
-            totalPayloadLength += comment.Value.Length + 4;
-        }
-
-        Span<byte> payload = new byte[totalPayloadLength];
-        int currentCommentStartingIndex = 0;
-
-        for (int i = 0; i < comments.Count; i++)
-        {
-            ReadOnlyMemory<char> comment = comments[i].Value;
+            // Loop through and split the comment into multiple comments if the comment length
+            // is greater than the maximum allowed length.
+            while (totalLength > 0)
+            {
+                int currentLength = Math.Min(totalLength, maxCommentLength);
 
-            // Beginning of comment ff fe
-            payload[currentCommentStartingIndex] = JpegConstants.Markers.XFF;
-            payload[currentCommentStartingIndex + 1] = JpegConstants.Markers.COM;
+                // Write the marker header.
+                this.WriteMarkerHeader(JpegConstants.Markers.COM, currentLength + 2, buffer);
 
-            // Write payload size
-            int comWithoutMarker = comment.Length + 2;
-            payload[currentCommentStartingIndex + 2] = (byte)((comWithoutMarker >> 8) & 0xFF);
-            payload[currentCommentStartingIndex + 3] = (byte)(comWithoutMarker & 0xFF);
+                ReadOnlySpan<char> commentValue = comment.Value.Span.Slice(comment.Value.Length - totalLength, currentLength);
+                for (int i = 0; i < commentValue.Length; i++)
+                {
+                    buffer[i] = (byte)commentValue[i];
+                }
 
-            char[] commentChars = comment.ToArray();
-            for (int j = 0; j < commentChars.Length; j++)
-            {
-                // Initial 4 bytes are always reserved
-                payload[4 + currentCommentStartingIndex + j] = (byte)commentChars[j];
+                // Write the comment.
+                this.outputStream.Write(buffer, 0, currentLength);
+                totalLength -= currentLength;
             }
-
-            currentCommentStartingIndex += comment.Length + 4;
         }
-
-        this.outputStream.Write(payload, 0, payload.Length);
     }
 
     /// <summary>