diff --git a/ImageSharp.sln.DotSettings b/ImageSharp.sln.DotSettings index 435aad73bf..432f4524a0 100644 --- a/ImageSharp.sln.DotSettings +++ b/ImageSharp.sln.DotSettings @@ -343,8 +343,11 @@ <Entry DisplayName="All other members" /> </TypePattern> </Patterns> - True + False True + // Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + AC DC DCT diff --git a/build.ps1 b/build.ps1 index 4c5a36cae5..35b8344dcc 100644 --- a/build.ps1 +++ b/build.ps1 @@ -8,7 +8,7 @@ $tagRegex = '^v?(\d+\.\d+\.\d+)(-([a-zA-Z]+)\.?(\d*))?$' # we are running on the build server $isVersionTag = $env:APPVEYOR_REPO_TAG_NAME -match $tagRegex - if($isVersionTag){ + if($isVersionTag) { Write-Debug "Building commit tagged with a compatable version number" @@ -26,7 +26,8 @@ $isVersionTag = $env:APPVEYOR_REPO_TAG_NAME -match $tagRegex $version = "${version}${padded}" } - }else { + } + else { Write-Debug "Untagged" $lastTag = (git tag --list --sort=-taggerdate) | Out-String diff --git a/src/ImageSharp.Drawing/ImageSharp.Drawing.csproj b/src/ImageSharp.Drawing/ImageSharp.Drawing.csproj index 661f33e081..42ef080e53 100644 --- a/src/ImageSharp.Drawing/ImageSharp.Drawing.csproj +++ b/src/ImageSharp.Drawing/ImageSharp.Drawing.csproj @@ -37,10 +37,9 @@ - - - + + All diff --git a/src/ImageSharp.Drawing/Primitives/ShapeRegion.cs b/src/ImageSharp.Drawing/Primitives/ShapeRegion.cs index 9f5611dc04..812744b895 100644 --- a/src/ImageSharp.Drawing/Primitives/ShapeRegion.cs +++ b/src/ImageSharp.Drawing/Primitives/ShapeRegion.cs @@ -2,6 +2,9 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; + +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; using SixLabors.Primitives; using SixLabors.Shapes; @@ -45,7 +48,7 @@ namespace SixLabors.ImageSharp.Primitives var start = new PointF(this.Bounds.Left - 1, y); var end = new PointF(this.Bounds.Right + 1, y); - using (IBuffer tempBuffer = configuration.MemoryAllocator.Allocate(buffer.Length)) + using (IMemoryOwner tempBuffer = configuration.MemoryAllocator.Allocate(buffer.Length)) { Span innerBuffer = tempBuffer.GetSpan(); int count = this.Shape.FindIntersections(start, end, innerBuffer); diff --git a/src/ImageSharp.Drawing/Processing/BrushApplicator.cs b/src/ImageSharp.Drawing/Processing/BrushApplicator.cs index 0ac4e4dd10..41b47a822e 100644 --- a/src/ImageSharp.Drawing/Processing/BrushApplicator.cs +++ b/src/ImageSharp.Drawing/Processing/BrushApplicator.cs @@ -2,7 +2,10 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; + using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -65,8 +68,8 @@ namespace SixLabors.ImageSharp.Processing { MemoryAllocator memoryAllocator = this.Target.MemoryAllocator; - using (IBuffer amountBuffer = memoryAllocator.Allocate(scanline.Length)) - using (IBuffer overlay = memoryAllocator.Allocate(scanline.Length)) + using (IMemoryOwner amountBuffer = memoryAllocator.Allocate(scanline.Length)) + using (IMemoryOwner overlay = memoryAllocator.Allocate(scanline.Length)) { Span amountSpan = amountBuffer.GetSpan(); Span overlaySpan = overlay.GetSpan(); diff --git a/src/ImageSharp.Drawing/Processing/ImageBrush{TPixel}.cs b/src/ImageSharp.Drawing/Processing/ImageBrush{TPixel}.cs index 7e24dbbe24..c3f81868be 100644 --- a/src/ImageSharp.Drawing/Processing/ImageBrush{TPixel}.cs +++ b/src/ImageSharp.Drawing/Processing/ImageBrush{TPixel}.cs @@ -2,7 +2,9 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -118,8 +120,8 @@ namespace SixLabors.ImageSharp.Processing internal override void Apply(Span scanline, int x, int y) { // Create a span for colors - using (IBuffer amountBuffer = this.Target.MemoryAllocator.Allocate(scanline.Length)) - using (IBuffer overlay = this.Target.MemoryAllocator.Allocate(scanline.Length)) + using (IMemoryOwner amountBuffer = this.Target.MemoryAllocator.Allocate(scanline.Length)) + using (IMemoryOwner overlay = this.Target.MemoryAllocator.Allocate(scanline.Length)) { Span amountSpan = amountBuffer.GetSpan(); Span overlaySpan = overlay.GetSpan(); diff --git a/src/ImageSharp.Drawing/Processing/PatternBrush{TPixel}.cs b/src/ImageSharp.Drawing/Processing/PatternBrush{TPixel}.cs index 30d78bc839..2ce9a7ce57 100644 --- a/src/ImageSharp.Drawing/Processing/PatternBrush{TPixel}.cs +++ b/src/ImageSharp.Drawing/Processing/PatternBrush{TPixel}.cs @@ -2,8 +2,10 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Numerics; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; using SixLabors.Memory; @@ -153,8 +155,8 @@ namespace SixLabors.ImageSharp.Processing int patternY = y % this.pattern.Rows; MemoryAllocator memoryAllocator = this.Target.MemoryAllocator; - using (IBuffer amountBuffer = memoryAllocator.Allocate(scanline.Length)) - using (IBuffer overlay = memoryAllocator.Allocate(scanline.Length)) + using (IMemoryOwner amountBuffer = memoryAllocator.Allocate(scanline.Length)) + using (IMemoryOwner overlay = memoryAllocator.Allocate(scanline.Length)) { Span amountSpan = amountBuffer.GetSpan(); Span overlaySpan = overlay.GetSpan(); diff --git a/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs b/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs index e4b2eadb4a..faf3fe7115 100644 --- a/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs +++ b/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs @@ -2,8 +2,10 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -134,14 +136,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing MemoryAllocator memoryAllocator = this.Image.GetConfiguration().MemoryAllocator; - using (IBuffer amount = memoryAllocator.Allocate(width)) + using (IMemoryOwner amount = memoryAllocator.Allocate(width)) { amount.GetSpan().Fill(this.Opacity); - Parallel.For( + ParallelFor.WithConfiguration( minY, maxY, - configuration.ParallelOptions, + configuration, y => { Span background = source.GetPixelRowSpan(y).Slice(minX, width); diff --git a/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillProcessor.cs b/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillProcessor.cs index 595c94687a..c9d6777ce6 100644 --- a/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillProcessor.cs +++ b/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillProcessor.cs @@ -2,10 +2,11 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; -using SixLabors.ImageSharp.Processing; using SixLabors.Memory; using SixLabors.Primitives; @@ -54,10 +55,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing // If there's no reason for blending, then avoid it. if (this.IsSolidBrushWithoutBlending(out SolidBrush solidBrush)) { - Parallel.For( + ParallelFor.WithConfiguration( minY, maxY, - configuration.ParallelOptions, + configuration, y => { source.GetPixelRowSpan(y).Slice(minX, width).Fill(solidBrush.Color); @@ -76,7 +77,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing startY = 0; } - using (IBuffer amount = source.MemoryAllocator.Allocate(width)) + using (IMemoryOwner amount = source.MemoryAllocator.Allocate(width)) using (BrushApplicator applicator = this.brush.CreateApplicator( source, sourceRectangle, @@ -84,10 +85,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing { amount.GetSpan().Fill(1f); - Parallel.For( + ParallelFor.WithConfiguration( minY, maxY, - configuration.ParallelOptions, + configuration, y => { int offsetY = y - startY; diff --git a/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillRegionProcessor.cs b/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillRegionProcessor.cs index 1cc954dd91..514249a2d4 100644 --- a/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillRegionProcessor.cs +++ b/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillRegionProcessor.cs @@ -2,6 +2,9 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; using SixLabors.ImageSharp.Utils; @@ -94,8 +97,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing using (BrushApplicator applicator = this.Brush.CreateApplicator(source, rect, this.Options)) { int scanlineWidth = maxX - minX; - using (IBuffer bBuffer = source.MemoryAllocator.Allocate(maxIntersections)) - using (IBuffer bScanline = source.MemoryAllocator.Allocate(scanlineWidth)) + using (IMemoryOwner bBuffer = source.MemoryAllocator.Allocate(maxIntersections)) + using (IMemoryOwner bScanline = source.MemoryAllocator.Allocate(scanlineWidth)) { bool scanlineDirty = true; float subpixelFraction = 1f / subpixelCount; diff --git a/src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor.cs b/src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor.cs index 9f1158154c..6da635c981 100644 --- a/src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor.cs +++ b/src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor.cs @@ -2,9 +2,11 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Collections.Generic; using SixLabors.Fonts; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Utils; using SixLabors.Memory; @@ -334,10 +336,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Text } // take the path inside the path builder, scan thing and generate a Buffer2d representing the glyph and cache it. - Buffer2D fullBuffer = this.MemoryAllocator.Allocate2D(size.Width + 1, size.Height + 1, true); + Buffer2D fullBuffer = this.MemoryAllocator.Allocate2D(size.Width + 1, size.Height + 1, AllocationOptions.Clean); - using (IBuffer bufferBacking = this.MemoryAllocator.Allocate(path.MaxIntersections)) - using (IBuffer rowIntersectionBuffer = this.MemoryAllocator.Allocate(size.Width)) + using (IMemoryOwner bufferBacking = this.MemoryAllocator.Allocate(path.MaxIntersections)) + using (IMemoryOwner rowIntersectionBuffer = this.MemoryAllocator.Allocate(size.Width)) { float subpixelFraction = 1f / subpixelCount; float subpixelFractionPoint = subpixelFraction / subpixelCount; diff --git a/src/ImageSharp.Drawing/Processing/RecolorBrush{TPixel}.cs b/src/ImageSharp.Drawing/Processing/RecolorBrush{TPixel}.cs index 058b03d621..87e1dc146a 100644 --- a/src/ImageSharp.Drawing/Processing/RecolorBrush{TPixel}.cs +++ b/src/ImageSharp.Drawing/Processing/RecolorBrush{TPixel}.cs @@ -2,8 +2,10 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Numerics; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -138,8 +140,8 @@ namespace SixLabors.ImageSharp.Processing { MemoryAllocator memoryAllocator = this.Target.MemoryAllocator; - using (IBuffer amountBuffer = memoryAllocator.Allocate(scanline.Length)) - using (IBuffer overlay = memoryAllocator.Allocate(scanline.Length)) + using (IMemoryOwner amountBuffer = memoryAllocator.Allocate(scanline.Length)) + using (IMemoryOwner overlay = memoryAllocator.Allocate(scanline.Length)) { Span amountSpan = amountBuffer.GetSpan(); Span overlaySpan = overlay.GetSpan(); diff --git a/src/ImageSharp.Drawing/Processing/SolidBrush{TPixel}.cs b/src/ImageSharp.Drawing/Processing/SolidBrush{TPixel}.cs index 8a2d47c6c8..6b69c33f07 100644 --- a/src/ImageSharp.Drawing/Processing/SolidBrush{TPixel}.cs +++ b/src/ImageSharp.Drawing/Processing/SolidBrush{TPixel}.cs @@ -2,7 +2,10 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; + using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -65,7 +68,7 @@ namespace SixLabors.ImageSharp.Processing /// /// Gets the colors. /// - protected IBuffer Colors { get; } + protected IMemoryOwner Colors { get; } /// /// Gets the color for a single pixel. @@ -96,7 +99,7 @@ namespace SixLabors.ImageSharp.Processing } else { - using (IBuffer amountBuffer = memoryAllocator.Allocate(scanline.Length)) + using (IMemoryOwner amountBuffer = memoryAllocator.Allocate(scanline.Length)) { Span amountSpan = amountBuffer.GetSpan(); diff --git a/src/ImageSharp/Advanced/AdvancedImageExtensions.cs b/src/ImageSharp/Advanced/AdvancedImageExtensions.cs index 18b1d994b3..328d575969 100644 --- a/src/ImageSharp/Advanced/AdvancedImageExtensions.cs +++ b/src/ImageSharp/Advanced/AdvancedImageExtensions.cs @@ -3,6 +3,8 @@ using System; using System.Runtime.InteropServices; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -105,7 +107,7 @@ namespace SixLabors.ImageSharp.Advanced internal static Memory GetPixelMemory(this ImageFrame source) where TPixel : struct, IPixel { - return source.PixelBuffer.Buffer.Memory; + return source.PixelBuffer.MemorySource.Memory; } /// diff --git a/src/ImageSharp/Advanced/IPixelSource.cs b/src/ImageSharp/Advanced/IPixelSource.cs index 27b3170e63..19616d7427 100644 --- a/src/ImageSharp/Advanced/IPixelSource.cs +++ b/src/ImageSharp/Advanced/IPixelSource.cs @@ -1,6 +1,7 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; diff --git a/src/ImageSharp/Common/Extensions/ConfigurationExtensions.cs b/src/ImageSharp/Common/Extensions/ConfigurationExtensions.cs new file mode 100644 index 0000000000..6bb5adc060 --- /dev/null +++ b/src/ImageSharp/Common/Extensions/ConfigurationExtensions.cs @@ -0,0 +1,22 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Threading.Tasks; + +namespace SixLabors.ImageSharp +{ + /// + /// Contains extension methods for + /// + internal static class ConfigurationExtensions + { + /// + /// Creates a object based on , + /// having set to + /// + public static ParallelOptions GetParallelOptions(this Configuration configuration) + { + return new ParallelOptions() { MaxDegreeOfParallelism = configuration.MaxDegreeOfParallelism }; + } + } +} \ No newline at end of file diff --git a/src/ImageSharp/Common/Extensions/StreamExtensions.cs b/src/ImageSharp/Common/Extensions/StreamExtensions.cs index d11ba8ca57..a200ffebcc 100644 --- a/src/ImageSharp/Common/Extensions/StreamExtensions.cs +++ b/src/ImageSharp/Common/Extensions/StreamExtensions.cs @@ -4,6 +4,9 @@ using System; using System.IO; +using SixLabors.ImageSharp.Memory; +using SixLabors.Memory; + namespace SixLabors.ImageSharp { /// @@ -69,5 +72,15 @@ namespace SixLabors.ImageSharp } } } + + public static void Read(this Stream stream, IManagedByteBuffer buffer) + { + stream.Read(buffer.Array, 0, buffer.Length()); + } + + public static void Write(this Stream stream, IManagedByteBuffer buffer) + { + stream.Write(buffer.Array, 0, buffer.Length()); + } } } diff --git a/src/ImageSharp/Common/Helpers/ParallelFor.cs b/src/ImageSharp/Common/Helpers/ParallelFor.cs index 7061475a7c..4c14bb6e3d 100644 --- a/src/ImageSharp/Common/Helpers/ParallelFor.cs +++ b/src/ImageSharp/Common/Helpers/ParallelFor.cs @@ -1,4 +1,5 @@ using System; +using System.Buffers; using System.Threading.Tasks; using SixLabors.Memory; @@ -10,11 +11,11 @@ namespace SixLabors.ImageSharp internal static class ParallelFor { /// - /// Helper method to execute Parallel.For using the settings in + /// Helper method to execute Parallel.For using the settings in /// public static void WithConfiguration(int fromInclusive, int toExclusive, Configuration configuration, Action body) { - Parallel.For(fromInclusive, toExclusive, configuration.ParallelOptions, body); + Parallel.For(fromInclusive, toExclusive, configuration.GetParallelOptions(), body); } /// @@ -32,23 +33,23 @@ namespace SixLabors.ImageSharp int toExclusive, Configuration configuration, int bufferLength, - Action> body) + Action> body) where T : struct { MemoryAllocator memoryAllocator = configuration.MemoryAllocator; - ParallelOptions parallelOptions = configuration.ParallelOptions; + ParallelOptions parallelOptions = configuration.GetParallelOptions(); - IBuffer InitBuffer() + IMemoryOwner InitBuffer() { return memoryAllocator.Allocate(bufferLength); } - void CleanUpBuffer(IBuffer buffer) + void CleanUpBuffer(IMemoryOwner buffer) { buffer.Dispose(); } - IBuffer BodyFunc(int i, ParallelLoopState state, IBuffer buffer) + IMemoryOwner BodyFunc(int i, ParallelLoopState state, IMemoryOwner buffer) { body(i, buffer); return buffer; diff --git a/src/ImageSharp/Configuration.cs b/src/ImageSharp/Configuration.cs index e84674355e..1b009bfedd 100644 --- a/src/ImageSharp/Configuration.cs +++ b/src/ImageSharp/Configuration.cs @@ -27,6 +27,8 @@ namespace SixLabors.ImageSharp /// private static readonly Lazy Lazy = new Lazy(CreateDefaultInstance); + private int maxDegreeOfParallelism = Environment.ProcessorCount; + /// /// Initializes a new instance of the class. /// @@ -55,9 +57,22 @@ namespace SixLabors.ImageSharp public static Configuration Default { get; } = Lazy.Value; /// - /// Gets the global parallel options for processing tasks in parallel. + /// Gets or sets the maximum number of concurrent tasks enabled in ImageSharp algorithms + /// configured with this instance. /// - public ParallelOptions ParallelOptions { get; private set; } = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }; + public int MaxDegreeOfParallelism + { + get => this.maxDegreeOfParallelism; + set + { + if (value <= 0) + { + throw new ArgumentOutOfRangeException(nameof(this.MaxDegreeOfParallelism)); + } + + this.maxDegreeOfParallelism = value; + } + } /// /// Gets the currently registered s. @@ -114,7 +129,7 @@ namespace SixLabors.ImageSharp { return new Configuration { - ParallelOptions = this.ParallelOptions, + MaxDegreeOfParallelism = this.MaxDegreeOfParallelism, ImageFormatsManager = this.ImageFormatsManager, MemoryAllocator = this.MemoryAllocator, ImageOperationsProvider = this.ImageOperationsProvider, diff --git a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs index c135ab6d68..128ae08542 100644 --- a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs +++ b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs @@ -6,6 +6,7 @@ using System.Buffers.Binary; using System.IO; using System.Runtime.CompilerServices; using SixLabors.ImageSharp.Common.Helpers; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -226,7 +227,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp TPixel color = default; var rgba = new Rgba32(0, 0, 0, 255); - using (Buffer2D buffer = this.memoryAllocator.AllocateClean2D(width, height)) + using (Buffer2D buffer = this.memoryAllocator.Allocate2D(width, height, AllocationOptions.Clean)) { this.UncompressRle8(width, buffer.GetSpan()); @@ -354,7 +355,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp padding = 4 - padding; } - using (IManagedByteBuffer row = this.memoryAllocator.AllocateCleanManagedByteBuffer(arrayWidth + padding)) + using (IManagedByteBuffer row = this.memoryAllocator.AllocateManagedByteBuffer(arrayWidth + padding, AllocationOptions.Clean)) { TPixel color = default; var rgba = new Rgba32(0, 0, 0, 255); diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs index 80fc6330a7..b49b8a8959 100644 --- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs +++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs @@ -4,6 +4,7 @@ using System; using System.IO; using SixLabors.ImageSharp.Common.Helpers; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; diff --git a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs index 462f09897c..3832a30c68 100644 --- a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs +++ b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs @@ -7,6 +7,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Text; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -321,11 +322,11 @@ namespace SixLabors.ImageSharp.Formats.Gif if (imageDescriptor.LocalColorTableFlag) { int length = imageDescriptor.LocalColorTableSize * 3; - localColorTable = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(length, true); + localColorTable = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(length, AllocationOptions.Clean); this.stream.Read(localColorTable.Array, 0, length); } - indices = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(imageDescriptor.Width * imageDescriptor.Height, true); + indices = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(imageDescriptor.Width * imageDescriptor.Height, AllocationOptions.Clean); this.ReadFrameIndices(imageDescriptor, indices.GetSpan()); ReadOnlySpan colorTable = MemoryMarshal.Cast((localColorTable ?? this.globalColorTable).GetSpan()); @@ -556,7 +557,7 @@ namespace SixLabors.ImageSharp.Formats.Gif { int globalColorTableLength = this.logicalScreenDescriptor.GlobalColorTableSize * 3; - this.globalColorTable = this.MemoryAllocator.AllocateManagedByteBuffer(globalColorTableLength, true); + this.globalColorTable = this.MemoryAllocator.AllocateManagedByteBuffer(globalColorTableLength, AllocationOptions.Clean); // Read the global color table data from the stream stream.Read(this.globalColorTable.Array, 0, globalColorTableLength); diff --git a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs index ea507c7811..1fb706ae18 100644 --- a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs +++ b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs @@ -7,6 +7,8 @@ using System.IO; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Text; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing.Processors.Quantization; diff --git a/src/ImageSharp/Formats/Gif/LzwDecoder.cs b/src/ImageSharp/Formats/Gif/LzwDecoder.cs index 35eb43a8a8..3c7b6a4af6 100644 --- a/src/ImageSharp/Formats/Gif/LzwDecoder.cs +++ b/src/ImageSharp/Formats/Gif/LzwDecoder.cs @@ -2,9 +2,12 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.IO; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; + +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; namespace SixLabors.ImageSharp.Formats.Gif @@ -32,17 +35,17 @@ namespace SixLabors.ImageSharp.Formats.Gif /// /// The prefix buffer. /// - private readonly IBuffer prefix; + private readonly IMemoryOwner prefix; /// /// The suffix buffer. /// - private readonly IBuffer suffix; + private readonly IMemoryOwner suffix; /// /// The pixel stack buffer. /// - private readonly IBuffer pixelStack; + private readonly IMemoryOwner pixelStack; /// /// Initializes a new instance of the class @@ -57,9 +60,9 @@ namespace SixLabors.ImageSharp.Formats.Gif this.stream = stream; - this.prefix = memoryAllocator.Allocate(MaxStackSize, true); - this.suffix = memoryAllocator.Allocate(MaxStackSize, true); - this.pixelStack = memoryAllocator.Allocate(MaxStackSize + 1, true); + this.prefix = memoryAllocator.Allocate(MaxStackSize, AllocationOptions.Clean); + this.suffix = memoryAllocator.Allocate(MaxStackSize, AllocationOptions.Clean); + this.pixelStack = memoryAllocator.Allocate(MaxStackSize + 1, AllocationOptions.Clean); } /// diff --git a/src/ImageSharp/Formats/Gif/LzwEncoder.cs b/src/ImageSharp/Formats/Gif/LzwEncoder.cs index 347609a549..e390dfd54c 100644 --- a/src/ImageSharp/Formats/Gif/LzwEncoder.cs +++ b/src/ImageSharp/Formats/Gif/LzwEncoder.cs @@ -2,9 +2,12 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.IO; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; + +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; namespace SixLabors.ImageSharp.Formats.Gif @@ -66,12 +69,12 @@ namespace SixLabors.ImageSharp.Formats.Gif /// /// The hash table. /// - private readonly IBuffer hashTable; + private readonly IMemoryOwner hashTable; /// /// The code table. /// - private readonly IBuffer codeTable; + private readonly IMemoryOwner codeTable; /// /// Define the storage for the packet accumulator. @@ -168,8 +171,8 @@ namespace SixLabors.ImageSharp.Formats.Gif public LzwEncoder(MemoryAllocator memoryAllocator, int colorDepth) { this.initialCodeSize = Math.Max(2, colorDepth); - this.hashTable = memoryAllocator.Allocate(HashSize, true); - this.codeTable = memoryAllocator.Allocate(HashSize, true); + this.hashTable = memoryAllocator.Allocate(HashSize, AllocationOptions.Clean); + this.codeTable = memoryAllocator.Allocate(HashSize, AllocationOptions.Clean); } /// diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.CopyTo.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.CopyTo.cs index 4db6d74317..bebc13f6de 100644 --- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.CopyTo.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.CopyTo.cs @@ -4,6 +4,7 @@ using System.Numerics; using System.Runtime.CompilerServices; +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; // ReSharper disable InconsistentNaming diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs index 2937b23a7e..40b8d391a3 100644 --- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs @@ -7,6 +7,7 @@ using System.Linq; using System.Numerics; using SixLabors.ImageSharp.Common.Tuples; +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FastACTables.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FastACTables.cs similarity index 86% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FastACTables.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/FastACTables.cs index 6cb0d6dfe5..26bcde8e51 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FastACTables.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FastACTables.cs @@ -3,9 +3,11 @@ using System; using System.Runtime.CompilerServices; + +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { /// /// The collection of lookup tables used for fast AC entropy scan decoding. @@ -20,7 +22,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// The memory allocator used to allocate memory for image processing operations. public FastACTables(MemoryAllocator memoryAllocator) { - this.tables = memoryAllocator.AllocateClean2D(512, 4); + this.tables = memoryAllocator.Allocate2D(512, 4, AllocationOptions.Clean); } /// @@ -35,10 +37,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } /// - /// Gets a reference to the first element of the AC table indexed by - /// + /// Gets a reference to the first element of the AC table indexed by /// [MethodImpl(MethodImplOptions.AggressiveInlining)] - public ref short GetAcTableReference(PdfJsFrameComponent component) + public ref short GetAcTableReference(JpegComponent component) { return ref this.tables.GetRowSpan(component.ACHuffmanTableId)[0]; } @@ -48,11 +49,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// The table index. /// The collection of AC Huffman tables. - public void BuildACTableLut(int index, PdfJsHuffmanTables acHuffmanTables) + public void BuildACTableLut(int index, HuffmanTables acHuffmanTables) { const int FastBits = ScanDecoder.FastBits; Span fastAC = this.tables.GetRowSpan(index); - ref PdfJsHuffmanTable huffman = ref acHuffmanTables[index]; + ref HuffmanTable huffman = ref acHuffmanTables[index]; int i; for (i = 0; i < (1 << FastBits); i++) diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedByteBuffer256.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedByteBuffer256.cs similarity index 90% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedByteBuffer256.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedByteBuffer256.cs index 5870e3da8e..1d26178e0c 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedByteBuffer256.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedByteBuffer256.cs @@ -4,7 +4,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { [StructLayout(LayoutKind.Sequential)] internal unsafe struct FixedByteBuffer256 diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedByteBuffer512.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedByteBuffer512.cs similarity index 90% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedByteBuffer512.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedByteBuffer512.cs index c509903c98..556e74fd58 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedByteBuffer512.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedByteBuffer512.cs @@ -4,7 +4,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { [StructLayout(LayoutKind.Sequential)] internal unsafe struct FixedByteBuffer512 diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedInt16Buffer257.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedInt16Buffer257.cs similarity index 90% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedInt16Buffer257.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedInt16Buffer257.cs index b304dbf8c2..a3b67a700b 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedInt16Buffer257.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedInt16Buffer257.cs @@ -4,7 +4,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { [StructLayout(LayoutKind.Sequential)] internal unsafe struct FixedInt16Buffer257 diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedInt32Buffer18.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedInt32Buffer18.cs similarity index 90% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedInt32Buffer18.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedInt32Buffer18.cs index f8507ec47c..bba89f072f 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedInt32Buffer18.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedInt32Buffer18.cs @@ -4,7 +4,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { [StructLayout(LayoutKind.Sequential)] internal unsafe struct FixedInt32Buffer18 diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedUInt32Buffer18.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedUInt32Buffer18.cs similarity index 90% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedUInt32Buffer18.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedUInt32Buffer18.cs index 9b076d9daa..1d3ca99338 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FixedUInt32Buffer18.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/FixedUInt32Buffer18.cs @@ -4,7 +4,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { [StructLayout(LayoutKind.Sequential)] internal unsafe struct FixedUInt32Buffer18 diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsHuffmanTable.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanTable.cs similarity index 90% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsHuffmanTable.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanTable.cs index 15ae56331c..0138164ed2 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsHuffmanTable.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanTable.cs @@ -2,17 +2,20 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; + +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { /// /// Represents a Huffman Table /// [StructLayout(LayoutKind.Sequential)] - internal unsafe struct PdfJsHuffmanTable + internal unsafe struct HuffmanTable { /// /// Gets the max code array @@ -40,15 +43,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components public FixedInt16Buffer257 Sizes; /// - /// Initializes a new instance of the struct. + /// Initializes a new instance of the struct. /// /// The to use for buffer allocations. /// The code lengths /// The huffman values - public PdfJsHuffmanTable(MemoryAllocator memoryAllocator, ReadOnlySpan count, ReadOnlySpan values) + public HuffmanTable(MemoryAllocator memoryAllocator, ReadOnlySpan count, ReadOnlySpan values) { const int Length = 257; - using (IBuffer huffcode = memoryAllocator.Allocate(Length)) + using (IMemoryOwner huffcode = memoryAllocator.Allocate(Length)) { ref short huffcodeRef = ref MemoryMarshal.GetReference(huffcode.GetSpan()); diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsHuffmanTables.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanTables.cs similarity index 54% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsHuffmanTables.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanTables.cs index 5cbde2b88c..dc066aa0ac 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsHuffmanTables.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanTables.cs @@ -1,24 +1,23 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. -using System.Collections.Generic; using System.Runtime.CompilerServices; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { /// - /// Defines a 2 pairs of huffman tables + /// Defines a 2 pairs of huffman tables. /// - internal sealed class PdfJsHuffmanTables + internal sealed class HuffmanTables { - private readonly PdfJsHuffmanTable[] tables = new PdfJsHuffmanTable[4]; + private readonly HuffmanTable[] tables = new HuffmanTable[4]; /// /// Gets or sets the table at the given index. /// /// The index - /// The - public ref PdfJsHuffmanTable this[int index] + /// The + public ref HuffmanTable this[int index] { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => ref this.tables[index]; diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/IJpegComponent.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/IJpegComponent.cs index 253b20c39c..c033980336 100644 --- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/IJpegComponent.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/IJpegComponent.cs @@ -1,6 +1,7 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; using SixLabors.Primitives; diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs index 2baefff9b6..900dd3bc89 100644 --- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs @@ -3,13 +3,14 @@ using System.Runtime.InteropServices; +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; using SixLabors.Primitives; namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { /// - /// Encapsulates the implementation of processing "raw" -s into Jpeg image channels. + /// Encapsulates the implementation of processing "raw" jpeg buffers into Jpeg image channels. /// [StructLayout(LayoutKind.Sequential)] internal struct JpegBlockPostProcessor diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsFrameComponent.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponent.cs similarity index 82% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsFrameComponent.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponent.cs index 7501b0d83c..65a584c4f2 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsFrameComponent.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponent.cs @@ -5,21 +5,20 @@ using System; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -using SixLabors.ImageSharp.Formats.Jpeg.Components; -using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; using SixLabors.Primitives; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { /// /// Represents a single frame component /// - internal class PdfJsFrameComponent : IDisposable, IJpegComponent + internal class JpegComponent : IDisposable, IJpegComponent { private readonly MemoryAllocator memoryAllocator; - public PdfJsFrameComponent(MemoryAllocator memoryAllocator, PdfJsFrame frame, byte id, int horizontalFactor, int verticalFactor, byte quantizationTableIndex, int index) + public JpegComponent(MemoryAllocator memoryAllocator, JpegFrame frame, byte id, int horizontalFactor, int verticalFactor, byte quantizationTableIndex, int index) { this.memoryAllocator = memoryAllocator; this.Frame = frame; @@ -89,7 +88,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// public int ACHuffmanTableId { get; set; } - public PdfJsFrame Frame { get; } + public JpegFrame Frame { get; } /// public void Dispose() @@ -125,11 +124,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } else { - PdfJsFrameComponent c0 = this.Frame.Components[0]; + JpegComponent c0 = this.Frame.Components[0]; this.SubSamplingDivisors = c0.SamplingFactors.DivideBy(this.SamplingFactors); } - this.SpectralBlocks = this.memoryAllocator.AllocateClean2D(blocksPerColumnForMcu, blocksPerLineForMcu + 1); + this.SpectralBlocks = this.memoryAllocator.Allocate2D(blocksPerColumnForMcu, blocksPerLineForMcu + 1, AllocationOptions.Clean); } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -140,16 +139,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - public int GetBlockBufferOffset(int row, int col) + public ref short GetBlockDataReference(int column, int row) { - return 64 * (((this.WidthInBlocks + 1) * row) + col); - } - - // TODO: we need consistence in (row, col) VS (col, row) ordering - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public ref short GetBlockDataReference(int row, int col) - { - ref Block8x8 blockRef = ref this.GetBlockReference(col, row); + ref Block8x8 blockRef = ref this.GetBlockReference(column, row); return ref Unsafe.As(ref blockRef); } } diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs index 2b442fcdc9..890f402595 100644 --- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs @@ -3,6 +3,7 @@ using System; +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; using SixLabors.Primitives; diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsFileMarker.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegFileMarker.cs similarity index 74% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsFileMarker.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegFileMarker.cs index 85c9f94666..d2b0ee26e4 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsFileMarker.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegFileMarker.cs @@ -3,32 +3,30 @@ using System.Runtime.CompilerServices; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { /// - /// Represents a jpeg file marker + /// Represents a jpeg file marker. /// - internal readonly struct PdfJsFileMarker + internal readonly struct JpegFileMarker { /// - /// Initializes a new instance of the struct. + /// Initializes a new instance of the struct. /// /// The marker /// The position within the stream - public PdfJsFileMarker(byte marker, long position) + public JpegFileMarker(byte marker, long position) + : this(marker, position, false) { - this.Marker = marker; - this.Position = position; - this.Invalid = false; } /// - /// Initializes a new instance of the struct. + /// Initializes a new instance of the struct. /// /// The marker /// The position within the stream /// Whether the current marker is invalid - public PdfJsFileMarker(byte marker, long position, bool invalid) + public JpegFileMarker(byte marker, long position, bool invalid) { this.Marker = marker; this.Position = position; diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsFrame.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegFrame.cs similarity index 92% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsFrame.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegFrame.cs index 8ce981a09d..da089fa44a 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsFrame.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegFrame.cs @@ -3,12 +3,12 @@ using System; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { /// /// Represent a single jpeg frame /// - internal sealed class PdfJsFrame : IDisposable + internal sealed class JpegFrame : IDisposable { /// /// Gets or sets a value indicating whether the frame uses the extended specification @@ -48,7 +48,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Gets or sets the frame component collection /// - public PdfJsFrameComponent[] Components { get; set; } + public JpegComponent[] Components { get; set; } /// /// Gets or sets the maximum horizontal sampling factor @@ -94,7 +94,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components for (int i = 0; i < this.ComponentCount; i++) { - PdfJsFrameComponent component = this.Components[i]; + JpegComponent component = this.Components[i]; component.Init(); } } diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegImagePostProcessor.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegImagePostProcessor.cs index 99408cf576..94382553ca 100644 --- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegImagePostProcessor.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegImagePostProcessor.cs @@ -2,9 +2,11 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Linq; using System.Numerics; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -37,7 +39,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder /// /// Temporal buffer to store a row of colors. /// - private readonly IBuffer rgbaBuffer; + private readonly IMemoryOwner rgbaBuffer; /// /// The corresponding to the current determined by . diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ProfileResolver.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ProfileResolver.cs index 8273f20eaa..a6d5faaea1 100644 --- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ProfileResolver.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ProfileResolver.cs @@ -32,7 +32,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder public static readonly byte[] AdobeMarker = Encoding.UTF8.GetBytes("Adobe"); /// - /// Returns a value indicating whether the passed bytes are a match to the profile identifer + /// Returns a value indicating whether the passed bytes are a match to the profile identifier /// /// The bytes to check /// The profile identifier diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ScanDecoder.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ScanDecoder.cs similarity index 93% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ScanDecoder.cs rename to src/ImageSharp/Formats/Jpeg/Components/Decoder/ScanDecoder.cs index 8575bac69e..8c525335bc 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ScanDecoder.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ScanDecoder.cs @@ -2,10 +2,9 @@ // Licensed under the Apache License, Version 2.0. using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using SixLabors.ImageSharp.Formats.Jpeg.Components; +using SixLabors.ImageSharp.IO; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder { /// /// Decodes the Huffman encoded spectral scan. @@ -23,13 +22,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components // LUT Bias[n] = (-1 << n) + 1 private static readonly int[] Bias = { 0, -1, -3, -7, -15, -31, -63, -127, -255, -511, -1023, -2047, -4095, -8191, -16383, -32767 }; - private readonly PdfJsFrame frame; - private readonly PdfJsHuffmanTables dcHuffmanTables; - private readonly PdfJsHuffmanTables acHuffmanTables; + private readonly JpegFrame frame; + private readonly HuffmanTables dcHuffmanTables; + private readonly HuffmanTables acHuffmanTables; private readonly FastACTables fastACTables; private readonly DoubleBufferedStreamReader stream; - private readonly PdfJsFrameComponent[] components; + private readonly JpegComponent[] components; private readonly ZigZag dctZigZag; // The restart interval. @@ -97,9 +96,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// The successive approximation bit low end. public ScanDecoder( DoubleBufferedStreamReader stream, - PdfJsFrame frame, - PdfJsHuffmanTables dcHuffmanTables, - PdfJsHuffmanTables acHuffmanTables, + JpegFrame frame, + HuffmanTables dcHuffmanTables, + HuffmanTables acHuffmanTables, FastACTables fastACTables, int componentIndex, int componentsLength, @@ -177,10 +176,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components // Scan an interleaved mcu... process components in order for (int k = 0; k < this.componentsLength; k++) { - PdfJsFrameComponent component = this.components[k]; + JpegComponent component = this.components[k]; - ref PdfJsHuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId]; - ref PdfJsHuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId]; + ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId]; + ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId]; ref short fastACRef = ref this.fastACTables.GetAcTableReference(component); int h = component.HorizontalSamplingFactor; int v = component.VerticalSamplingFactor; @@ -231,13 +230,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// private void ParseBaselineDataNonInterleaved() { - PdfJsFrameComponent component = this.components[this.componentIndex]; + JpegComponent component = this.components[this.componentIndex]; int w = component.WidthInBlocks; int h = component.HeightInBlocks; - ref PdfJsHuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId]; - ref PdfJsHuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId]; + ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId]; + ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId]; ref short fastACRef = ref this.fastACTables.GetAcTableReference(component); int mcu = 0; @@ -296,8 +295,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components // Scan an interleaved mcu... process components in order for (int k = 0; k < this.componentsLength; k++) { - PdfJsFrameComponent component = this.components[k]; - ref PdfJsHuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId]; + JpegComponent component = this.components[k]; + ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId]; int h = component.HorizontalSamplingFactor; int v = component.VerticalSamplingFactor; @@ -345,13 +344,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// private void ParseProgressiveDataNonInterleaved() { - PdfJsFrameComponent component = this.components[this.componentIndex]; + JpegComponent component = this.components[this.componentIndex]; int w = component.WidthInBlocks; int h = component.HeightInBlocks; - ref PdfJsHuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId]; - ref PdfJsHuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId]; + ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId]; + ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId]; ref short fastACRef = ref this.fastACTables.GetAcTableReference(component); int mcu = 0; @@ -396,11 +395,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } private void DecodeBlockBaseline( - PdfJsFrameComponent component, + JpegComponent component, int row, int col, - ref PdfJsHuffmanTable dcTable, - ref PdfJsHuffmanTable acTable, + ref HuffmanTable dcTable, + ref HuffmanTable acTable, ref short fastACRef) { this.CheckBits(); @@ -411,7 +410,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components JpegThrowHelper.ThrowBadHuffmanCode(); } - ref short blockDataRef = ref component.GetBlockDataReference(row, col); + ref short blockDataRef = ref component.GetBlockDataReference(col, row); int diff = t != 0 ? this.ExtendReceive(t) : 0; int dc = component.DcPredictor + diff; @@ -475,10 +474,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } private void DecodeBlockProgressiveDC( - PdfJsFrameComponent component, + JpegComponent component, int row, int col, - ref PdfJsHuffmanTable dcTable) + ref HuffmanTable dcTable) { if (this.spectralEnd != 0) { @@ -487,7 +486,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components this.CheckBits(); - ref short blockDataRef = ref component.GetBlockDataReference(row, col); + ref short blockDataRef = ref component.GetBlockDataReference(col, row); if (this.successiveHigh == 0) { @@ -511,10 +510,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } private void DecodeBlockProgressiveAC( - PdfJsFrameComponent component, + JpegComponent component, int row, int col, - ref PdfJsHuffmanTable acTable, + ref HuffmanTable acTable, ref short fastACRef) { if (this.spectralStart == 0) @@ -522,7 +521,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components JpegThrowHelper.ThrowImageFormatException("Can't merge DC and AC."); } - ref short blockDataRef = ref component.GetBlockDataReference(row, col); + ref short blockDataRef = ref component.GetBlockDataReference(col, row); if (this.successiveHigh == 0) { @@ -603,7 +602,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } } - private void DecodeBlockProgressiveACRefined(ref short blockDataRef, ref PdfJsHuffmanTable acTable) + private void DecodeBlockProgressiveACRefined(ref short blockDataRef, ref HuffmanTable acTable) { int k; @@ -805,7 +804,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(InliningOptions.ShortMethod)] - private int DecodeHuffman(ref PdfJsHuffmanTable table) + private int DecodeHuffman(ref HuffmanTable table) { this.CheckBits(); @@ -830,7 +829,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(InliningOptions.ColdPath)] - private int DecodeHuffmanSlow(ref PdfJsHuffmanTable table) + private int DecodeHuffmanSlow(ref HuffmanTable table) { // Naive test is to shift the code_buffer down so k bits are // valid, then test against MaxCode. To speed this up, we've @@ -941,7 +940,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components for (int i = 0; i < this.components.Length; i++) { - PdfJsFrameComponent c = this.components[i]; + JpegComponent c = this.components[i]; c.DcPredictor = 0; } diff --git a/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.cs b/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.cs index 825a7f5f0e..c150242593 100644 --- a/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.cs +++ b/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.cs @@ -5,6 +5,7 @@ using System; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bits.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bits.cs deleted file mode 100644 index 353eb01fe2..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bits.cs +++ /dev/null @@ -1,155 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.Runtime.CompilerServices; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Holds the unprocessed bits that have been taken from the byte-stream. - /// The n least significant bits of a form the unread bits, to be read in MSB to - /// LSB order. - /// - internal struct Bits - { - /// - /// Gets or sets the accumulator. - /// - public int Accumulator; - - /// - /// Gets or sets the mask. - /// 0, with mask==0 when unreadbits==0.]]> - /// - public int Mask; - - /// - /// Gets or sets the number of unread bits in the accumulator. - /// - public int UnreadBits; - - /// - /// Reads bytes from the byte buffer to ensure that bits.UnreadBits is at - /// least n. For best performance (avoiding function calls inside hot loops), - /// the caller is the one responsible for first checking that bits.UnreadBits < n. - /// - /// The number of bits to ensure. - /// The - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void EnsureNBits(int n, ref InputProcessor inputProcessor) - { - GolangDecoderErrorCode errorCode = this.EnsureNBitsUnsafe(n, ref inputProcessor); - errorCode.EnsureNoError(); - } - - /// - /// Reads bytes from the byte buffer to ensure that bits.UnreadBits is at - /// least n. For best performance (avoiding function calls inside hot loops), - /// the caller is the one responsible for first checking that bits.UnreadBits < n. - /// This method does not throw. Returns instead. - /// - /// The number of bits to ensure. - /// The - /// Error code - public GolangDecoderErrorCode EnsureNBitsUnsafe(int n, ref InputProcessor inputProcessor) - { - while (true) - { - GolangDecoderErrorCode errorCode = this.EnsureBitsStepImpl(ref inputProcessor); - if (errorCode != GolangDecoderErrorCode.NoError || this.UnreadBits >= n) - { - return errorCode; - } - } - } - - /// - /// Unrolled version of for n==8 - /// - /// The - /// A - public GolangDecoderErrorCode Ensure8BitsUnsafe(ref InputProcessor inputProcessor) - { - return this.EnsureBitsStepImpl(ref inputProcessor); - } - - /// - /// Unrolled version of for n==1 - /// - /// The - /// A - public GolangDecoderErrorCode Ensure1BitUnsafe(ref InputProcessor inputProcessor) - { - return this.EnsureBitsStepImpl(ref inputProcessor); - } - - /// - /// Receive extend - /// - /// Byte - /// The - /// Read bits value - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public int ReceiveExtend(int t, ref InputProcessor inputProcessor) - { - GolangDecoderErrorCode errorCode = this.ReceiveExtendUnsafe(t, ref inputProcessor, out int x); - errorCode.EnsureNoError(); - return x; - } - - /// - /// Receive extend - /// - /// Byte - /// The - /// Read bits value - /// The - public GolangDecoderErrorCode ReceiveExtendUnsafe(int t, ref InputProcessor inputProcessor, out int x) - { - if (this.UnreadBits < t) - { - GolangDecoderErrorCode errorCode = this.EnsureNBitsUnsafe(t, ref inputProcessor); - if (errorCode != GolangDecoderErrorCode.NoError) - { - x = int.MaxValue; - return errorCode; - } - } - - this.UnreadBits -= t; - this.Mask >>= t; - int s = 1 << t; - x = (this.Accumulator >> this.UnreadBits) & (s - 1); - - if (x < (s >> 1)) - { - x += ((-1) << t) + 1; - } - - return GolangDecoderErrorCode.NoError; - } - - private GolangDecoderErrorCode EnsureBitsStepImpl(ref InputProcessor inputProcessor) - { - GolangDecoderErrorCode errorCode = inputProcessor.Bytes.ReadByteStuffedByteUnsafe(inputProcessor.InputStream, out int c); - - if (errorCode != GolangDecoderErrorCode.NoError) - { - return errorCode; - } - - this.Accumulator = (this.Accumulator << 8) | c; - this.UnreadBits += 8; - if (this.Mask == 0) - { - this.Mask = 1 << 7; - } - else - { - this.Mask <<= 8; - } - - return errorCode; - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bytes.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bytes.cs deleted file mode 100644 index c8c68aa7ea..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bytes.cs +++ /dev/null @@ -1,255 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; -using System.IO; -using System.Runtime.CompilerServices; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Bytes is a byte buffer, similar to a stream, except that it - /// has to be able to unread more than 1 byte, due to byte stuffing. - /// Byte stuffing is specified in section F.1.2.3. - /// TODO: Optimize buffer management inside this class! - /// - internal struct Bytes : IDisposable - { - /// - /// Specifies the buffer size for and - /// - public const int BufferSize = 4096; - - /// - /// Gets or sets the buffer. - /// buffer[i:j] are the buffered bytes read from the underlying - /// stream that haven't yet been passed further on. - /// - public byte[] Buffer; - - /// - /// Values of converted to -s - /// - public int[] BufferAsInt; - - /// - /// Start of bytes read - /// - public int I; - - /// - /// End of bytes read - /// - public int J; - - /// - /// Gets or sets the unreadable bytes. The number of bytes to back up i after - /// overshooting. It can be 0, 1 or 2. - /// - public int UnreadableBytes; - - /// - /// Creates a new instance of the , and initializes it's buffer. - /// - /// The bytes created - public static Bytes Create() - { - // DO NOT bother with buffers and array pooling here! - // It only makes things worse! - return new Bytes - { - Buffer = new byte[BufferSize], - BufferAsInt = new int[BufferSize] - }; - } - - /// - /// Disposes of the underlying buffer - /// - public void Dispose() - { - this.Buffer = null; - this.BufferAsInt = null; - } - - /// - /// ReadByteStuffedByte is like ReadByte but is for byte-stuffed Huffman data. - /// - /// Input stream - /// The result byte as - /// The - public GolangDecoderErrorCode ReadByteStuffedByteUnsafe(Stream inputStream, out int x) - { - // Take the fast path if bytes.buf contains at least two bytes. - if (this.I + 2 <= this.J) - { - x = this.BufferAsInt[this.I]; - this.I++; - this.UnreadableBytes = 1; - if (x != JpegConstants.Markers.XFFInt) - { - return GolangDecoderErrorCode.NoError; - } - - if (this.BufferAsInt[this.I] != 0x00) - { - return GolangDecoderErrorCode.MissingFF00; - } - - this.I++; - this.UnreadableBytes = 2; - x = JpegConstants.Markers.XFF; - return GolangDecoderErrorCode.NoError; - } - - this.UnreadableBytes = 0; - - GolangDecoderErrorCode errorCode = this.ReadByteAsIntUnsafe(inputStream, out x); - this.UnreadableBytes = 1; - if (errorCode != GolangDecoderErrorCode.NoError) - { - return errorCode; - } - - if (x != JpegConstants.Markers.XFF) - { - return GolangDecoderErrorCode.NoError; - } - - errorCode = this.ReadByteAsIntUnsafe(inputStream, out x); - this.UnreadableBytes = 2; - if (errorCode != GolangDecoderErrorCode.NoError) - { - return errorCode; - } - - if (x != 0x00) - { - return GolangDecoderErrorCode.MissingFF00; - } - - x = JpegConstants.Markers.XFF; - return GolangDecoderErrorCode.NoError; - } - - /// - /// Returns the next byte, whether buffered or not buffered. It does not care about byte stuffing. - /// - /// Input stream - /// The - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public byte ReadByte(Stream inputStream) - { - GolangDecoderErrorCode errorCode = this.ReadByteUnsafe(inputStream, out byte result); - errorCode.EnsureNoError(); - return result; - } - - /// - /// Extracts the next byte, whether buffered or not buffered into the result out parameter. It does not care about byte stuffing. - /// This method does not throw on format error, it returns a instead. - /// - /// Input stream - /// The result as out parameter - /// The - public GolangDecoderErrorCode ReadByteUnsafe(Stream inputStream, out byte result) - { - GolangDecoderErrorCode errorCode = GolangDecoderErrorCode.NoError; - while (this.I == this.J) - { - errorCode = this.FillUnsafe(inputStream); - if (errorCode != GolangDecoderErrorCode.NoError) - { - result = 0; - return errorCode; - } - } - - result = this.Buffer[this.I]; - this.I++; - this.UnreadableBytes = 0; - return errorCode; - } - - /// - /// Same as but the result is an - /// - /// The input stream - /// The result - /// A - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public GolangDecoderErrorCode ReadByteAsIntUnsafe(Stream inputStream, out int result) - { - GolangDecoderErrorCode errorCode = GolangDecoderErrorCode.NoError; - while (this.I == this.J) - { - errorCode = this.FillUnsafe(inputStream); - if (errorCode != GolangDecoderErrorCode.NoError) - { - result = 0; - return errorCode; - } - } - - result = this.BufferAsInt[this.I]; - this.I++; - this.UnreadableBytes = 0; - return errorCode; - } - - /// - /// Fills up the bytes buffer from the underlying stream. - /// It should only be called when there are no unread bytes in bytes. - /// - /// Thrown when reached end of stream unexpectedly. - /// Input stream - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void Fill(Stream inputStream) - { - GolangDecoderErrorCode errorCode = this.FillUnsafe(inputStream); - errorCode.EnsureNoError(); - } - - /// - /// Fills up the bytes buffer from the underlying stream. - /// It should only be called when there are no unread bytes in bytes. - /// This method does not throw , returns a instead! - /// - /// Input stream - /// The - public GolangDecoderErrorCode FillUnsafe(Stream inputStream) - { - if (this.I != this.J) - { - // Unrecoverable error in the input, throwing! - DecoderThrowHelper.ThrowImageFormatException.FillCalledWhenUnreadBytesExist(); - } - - // Move the last 2 bytes to the start of the buffer, in case we need - // to call UnreadByteStuffedByte. - if (this.J > 2) - { - this.Buffer[0] = this.Buffer[this.J - 2]; - this.Buffer[1] = this.Buffer[this.J - 1]; - this.I = 2; - this.J = 2; - } - - // Fill in the rest of the buffer. - int n = inputStream.Read(this.Buffer, this.J, this.Buffer.Length - this.J); - if (n == 0) - { - return GolangDecoderErrorCode.UnexpectedEndOfStream; - } - - this.J += n; - - for (int i = 0; i < this.Buffer.Length; i++) - { - this.BufferAsInt[i] = this.Buffer[i]; - } - - return GolangDecoderErrorCode.NoError; - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/DecoderThrowHelper.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/DecoderThrowHelper.cs deleted file mode 100644 index 2b2bc61ba8..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/DecoderThrowHelper.cs +++ /dev/null @@ -1,96 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; -using System.Runtime.CompilerServices; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Encapsulates exception thrower methods for the Jpeg Encoder - /// - internal static class DecoderThrowHelper - { - /// - /// Throws an exception that belongs to the given - /// - /// The - [MethodImpl(MethodImplOptions.NoInlining)] - public static void ThrowExceptionForErrorCode(this GolangDecoderErrorCode errorCode) - { - // REMARK: If this method throws for an image that is expected to be decodable, - // consider using the ***Unsafe variant of the parsing method that asks for ThrowExceptionForErrorCode() - // then verify the error code + implement fallback logic manually! - switch (errorCode) - { - case GolangDecoderErrorCode.NoError: - throw new ArgumentException("ThrowExceptionForErrorCode() called with NoError!", nameof(errorCode)); - case GolangDecoderErrorCode.MissingFF00: - throw new MissingFF00Exception(); - case GolangDecoderErrorCode.UnexpectedEndOfStream: - throw new EOFException(); - default: - throw new ArgumentOutOfRangeException(nameof(errorCode), errorCode, null); - } - } - - /// - /// Throws an exception if the given defines an error. - /// - /// The - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static void EnsureNoError(this GolangDecoderErrorCode errorCode) - { - if (errorCode != GolangDecoderErrorCode.NoError) - { - ThrowExceptionForErrorCode(errorCode); - } - } - - /// - /// Throws an exception if the given is . - /// - /// The - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static void EnsureNoEOF(this GolangDecoderErrorCode errorCode) - { - if (errorCode == GolangDecoderErrorCode.UnexpectedEndOfStream) - { - errorCode.ThrowExceptionForErrorCode(); - } - } - - /// - /// Encapsulates methods throwing different flavours of -s. - /// - public static class ThrowImageFormatException - { - /// - /// Throws "Fill called when unread bytes exist". - /// - [MethodImpl(MethodImplOptions.NoInlining)] - public static void FillCalledWhenUnreadBytesExist() - { - throw new ImageFormatException("Fill called when unread bytes exist!"); - } - - /// - /// Throws "Bad Huffman code". - /// - [MethodImpl(MethodImplOptions.NoInlining)] - public static void BadHuffmanCode() - { - throw new ImageFormatException("Bad Huffman code!"); - } - - /// - /// Throws "Uninitialized Huffman table". - /// - [MethodImpl(MethodImplOptions.NoInlining)] - public static void UninitializedHuffmanTable() - { - throw new ImageFormatException("Uninitialized Huffman table"); - } - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/EOFException.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/EOFException.cs deleted file mode 100644 index 60d9b1e1af..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/EOFException.cs +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// The EOF (End of File exception). - /// Thrown when the decoder encounters an EOF marker without a proceeding EOI (End Of Image) marker - /// TODO: Rename to UnexpectedEndOfStreamException - /// - internal class EOFException : Exception - { - /// - /// Initializes a new instance of the class. - /// - public EOFException() - : base("Reached end of stream before proceeding EOI marker!") - { - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangComponent.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangComponent.cs deleted file mode 100644 index 75cea5551f..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangComponent.cs +++ /dev/null @@ -1,253 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; -using System.Runtime.CompilerServices; - -using SixLabors.ImageSharp.Formats.Jpeg.Components; -using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; -using SixLabors.Memory; -using SixLabors.Primitives; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// - /// Represents a single color component - /// - internal class GolangComponent : IDisposable, IJpegComponent - { - public GolangComponent(byte identifier, int index) - { - this.Identifier = identifier; - this.Index = index; - } - - /// - /// Gets the identifier - /// - public byte Identifier { get; } - - /// - public int Index { get; } - - public Size SizeInBlocks { get; private set; } - - public Size SamplingFactors { get; private set; } - - public Size SubSamplingDivisors { get; private set; } - - public int HorizontalSamplingFactor => this.SamplingFactors.Width; - - public int VerticalSamplingFactor => this.SamplingFactors.Height; - - /// - public int QuantizationTableIndex { get; private set; } - - /// - /// - /// Gets the storing the "raw" frequency-domain decoded blocks. - /// We need to apply IDCT, dequantiazition and unzigging to transform them into color-space blocks. - /// This is done by . - /// When us true, we are touching these blocks multiple times - each time we process a Scan. - /// - public Buffer2D SpectralBlocks { get; private set; } - - /// - /// Initializes - /// - /// The to use for buffer allocations. - /// The instance - public void InitializeDerivedData(MemoryAllocator memoryAllocator, GolangJpegDecoderCore decoder) - { - // For 4-component images (either CMYK or YCbCrK), we only support two - // hv vectors: [0x11 0x11 0x11 0x11] and [0x22 0x11 0x11 0x22]. - // Theoretically, 4-component JPEG images could mix and match hv values - // but in practice, those two combinations are the only ones in use, - // and it simplifies the applyBlack code below if we can assume that: - // - for CMYK, the C and K channels have full samples, and if the M - // and Y channels subsample, they subsample both horizontally and - // vertically. - // - for YCbCrK, the Y and K channels have full samples. - this.SizeInBlocks = decoder.ImageSizeInMCU.MultiplyBy(this.SamplingFactors); - - if (this.Index == 0 || this.Index == 3) - { - this.SubSamplingDivisors = new Size(1, 1); - } - else - { - GolangComponent c0 = decoder.Components[0]; - this.SubSamplingDivisors = c0.SamplingFactors.DivideBy(this.SamplingFactors); - } - - this.SpectralBlocks = memoryAllocator.Allocate2D(this.SizeInBlocks.Width, this.SizeInBlocks.Height, true); - } - - /// - /// Initializes all component data except . - /// - /// The instance - public void InitializeCoreData(GolangJpegDecoderCore decoder) - { - // Section B.2.2 states that "the value of C_i shall be different from - // the values of C_1 through C_(i-1)". - int i = this.Index; - - for (int j = 0; j < this.Index; j++) - { - if (this.Identifier == decoder.Components[j].Identifier) - { - throw new ImageFormatException("Repeated component identifier"); - } - } - - this.QuantizationTableIndex = decoder.Temp[8 + (3 * i)]; - if (this.QuantizationTableIndex > GolangJpegDecoderCore.MaxTq) - { - throw new ImageFormatException("Bad Tq value"); - } - - byte hv = decoder.Temp[7 + (3 * i)]; - int h = hv >> 4; - int v = hv & 0x0f; - if (h < 1 || h > 4 || v < 1 || v > 4) - { - throw new ImageFormatException("Unsupported Luma/chroma subsampling ratio"); - } - - if (h == 3 || v == 3) - { - throw new ImageFormatException("Lnsupported subsampling ratio"); - } - - switch (decoder.ComponentCount) - { - case 1: - - // If a JPEG image has only one component, section A.2 says "this data - // is non-interleaved by definition" and section A.2.2 says "[in this - // case...] the order of data units within a scan shall be left-to-right - // and top-to-bottom... regardless of the values of H_1 and V_1". Section - // 4.8.2 also says "[for non-interleaved data], the MCU is defined to be - // one data unit". Similarly, section A.1.1 explains that it is the ratio - // of H_i to max_j(H_j) that matters, and similarly for V. For grayscale - // images, H_1 is the maximum H_j for all components j, so that ratio is - // always 1. The component's (h, v) is effectively always (1, 1): even if - // the nominal (h, v) is (2, 1), a 20x5 image is encoded in three 8x8 - // MCUs, not two 16x8 MCUs. - h = 1; - v = 1; - break; - - case 3: - - // For YCbCr images, we only support 4:4:4, 4:4:0, 4:2:2, 4:2:0, - // 4:1:1 or 4:1:0 chroma subsampling ratios. This implies that the - // (h, v) values for the Y component are either (1, 1), (1, 2), - // (2, 1), (2, 2), (4, 1) or (4, 2), and the Y component's values - // must be a multiple of the Cb and Cr component's values. We also - // assume that the two chroma components have the same subsampling - // ratio. - switch (i) - { - case 0: - { - // Y. - // We have already verified, above, that h and v are both - // either 1, 2 or 4, so invalid (h, v) combinations are those - // with v == 4. - if (v == 4) - { - throw new ImageFormatException("Unsupported subsampling ratio"); - } - - break; - } - - case 1: - { - // Cb. - Size s0 = decoder.Components[0].SamplingFactors; - - if (s0.Width % h != 0 || s0.Height % v != 0) - { - throw new ImageFormatException("Unsupported subsampling ratio"); - } - - break; - } - - case 2: - { - // Cr. - Size s1 = decoder.Components[1].SamplingFactors; - - if (s1.Width != h || s1.Height != v) - { - throw new ImageFormatException("Unsupported subsampling ratio"); - } - - break; - } - } - - break; - - case 4: - - // For 4-component images (either CMYK or YCbCrK), we only support two - // hv vectors: [0x11 0x11 0x11 0x11] and [0x22 0x11 0x11 0x22]. - // Theoretically, 4-component JPEG images could mix and match hv values - // but in practice, those two combinations are the only ones in use, - // and it simplifies the applyBlack code below if we can assume that: - // - for CMYK, the C and K channels have full samples, and if the M - // and Y channels subsample, they subsample both horizontally and - // vertically. - // - for YCbCrK, the Y and K channels have full samples. - switch (i) - { - case 0: - if (hv != 0x11 && hv != 0x22) - { - throw new ImageFormatException("Unsupported subsampling ratio"); - } - - break; - case 1: - case 2: - if (hv != 0x11) - { - throw new ImageFormatException("Unsupported subsampling ratio"); - } - - break; - case 3: - Size s0 = decoder.Components[0].SamplingFactors; - - if (s0.Width != h || s0.Height != v) - { - throw new ImageFormatException("Unsupported subsampling ratio"); - } - - break; - } - - break; - } - - this.SamplingFactors = new Size(h, v); - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public ref Block8x8 GetBlockReference(int column, int row) - { - return ref this.SpectralBlocks[column, row]; - } - - public void Dispose() - { - this.SpectralBlocks?.Dispose(); - } - } -} diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangComponentScan.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangComponentScan.cs deleted file mode 100644 index 6752768ffa..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangComponentScan.cs +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.Runtime.InteropServices; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Represents a component scan - /// - [StructLayout(LayoutKind.Sequential)] - internal struct GolangComponentScan - { - /// - /// Gets or sets the component index. - /// - public byte ComponentIndex; - - /// - /// Gets or sets the DC table selector - /// - public byte DcTableSelector; - - /// - /// Gets or sets the AC table selector - /// - public byte AcTableSelector; - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangDecoderErrorCode.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangDecoderErrorCode.cs deleted file mode 100644 index fa3364527c..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangDecoderErrorCode.cs +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Represents "recoverable" decoder errors. - /// - internal enum GolangDecoderErrorCode - { - /// - /// NoError - /// - NoError, - - /// - /// MissingFF00 - /// - // ReSharper disable once InconsistentNaming - MissingFF00, - - /// - /// End of stream reached unexpectedly - /// - UnexpectedEndOfStream - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangHuffmanTree.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangHuffmanTree.cs deleted file mode 100644 index dccce2aaa8..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangHuffmanTree.cs +++ /dev/null @@ -1,260 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Represents a Huffman tree - /// - [StructLayout(LayoutKind.Sequential)] - internal unsafe struct GolangHuffmanTree - { - /// - /// The index of the AC table row - /// - public const int AcTableIndex = 1; - - /// - /// The index of the DC table row - /// - public const int DcTableIndex = 0; - - /// - /// The maximum (inclusive) number of codes in a Huffman tree. - /// - public const int MaxNCodes = 256; - - /// - /// The maximum (inclusive) number of bits in a Huffman code. - /// - public const int MaxCodeLength = 16; - - /// - /// The maximum number of Huffman table classes - /// - public const int MaxTc = 1; - - /// - /// The maximum number of Huffman table identifiers - /// - public const int MaxTh = 3; - - /// - /// Row size of the Huffman table - /// - public const int ThRowSize = MaxTh + 1; - - /// - /// Number of Hufman Trees in the Huffman table - /// - public const int NumberOfTrees = (MaxTc + 1) * (MaxTh + 1); - - /// - /// The log-2 size of the Huffman decoder's look-up table. - /// - public const int LutSizeLog2 = 8; - - /// - /// Gets or sets the number of codes in the tree. - /// - public int Length; - - /// - /// Gets the look-up table for the next LutSize bits in the bit-stream. - /// The high 8 bits of the uint16 are the encoded value. The low 8 bits - /// are 1 plus the code length, or 0 if the value is too large to fit in - /// lutSize bits. - /// - public FixedInt32Buffer256 Lut; - - /// - /// Gets the the decoded values, sorted by their encoding. - /// - public FixedInt32Buffer256 Values; - - /// - /// Gets the array of minimum codes. - /// MinCodes[i] is the minimum code of length i, or -1 if there are no codes of that length. - /// - public FixedInt32Buffer16 MinCodes; - - /// - /// Gets the array of maximum codes. - /// MaxCodes[i] is the maximum code of length i, or -1 if there are no codes of that length. - /// - public FixedInt32Buffer16 MaxCodes; - - /// - /// Gets the array of indices. Indices[i] is the index into Values of MinCodes[i]. - /// - public FixedInt32Buffer16 Indices; - - /// - /// Creates and initializes an array of instances of size - /// - /// An array of instances representing the Huffman tables - public static GolangHuffmanTree[] CreateHuffmanTrees() - { - return new GolangHuffmanTree[NumberOfTrees]; - } - - /// - /// Internal part of the DHT processor, whatever does it mean - /// - /// The decoder instance - /// The temporary buffer that holds the data that has been read from the Jpeg stream - /// Remaining bits - public void ProcessDefineHuffmanTablesMarkerLoop( - ref InputProcessor inputProcessor, - byte[] defineHuffmanTablesData, - ref int remaining) - { - // Read nCodes and huffman.Valuess (and derive h.Length). - // nCodes[i] is the number of codes with code length i. - // h.Length is the total number of codes. - this.Length = 0; - - int[] ncodes = new int[MaxCodeLength]; - for (int i = 0; i < ncodes.Length; i++) - { - ncodes[i] = defineHuffmanTablesData[i + 1]; - this.Length += ncodes[i]; - } - - if (this.Length == 0) - { - throw new ImageFormatException("Huffman table has zero length"); - } - - if (this.Length > MaxNCodes) - { - throw new ImageFormatException("Huffman table has excessive length"); - } - - remaining -= this.Length + 17; - if (remaining < 0) - { - throw new ImageFormatException("DHT has wrong length"); - } - - byte[] values = new byte[MaxNCodes]; - inputProcessor.ReadFull(values, 0, this.Length); - - fixed (int* valuesPtr = this.Values.Data) - fixed (int* lutPtr = this.Lut.Data) - { - for (int i = 0; i < values.Length; i++) - { - valuesPtr[i] = values[i]; - } - - // Derive the look-up table. - for (int i = 0; i < MaxNCodes; i++) - { - lutPtr[i] = 0; - } - - int x = 0, code = 0; - - for (int i = 0; i < LutSizeLog2; i++) - { - code <<= 1; - - for (int j = 0; j < ncodes[i]; j++) - { - // The codeLength is 1+i, so shift code by 8-(1+i) to - // calculate the high bits for every 8-bit sequence - // whose codeLength's high bits matches code. - // The high 8 bits of lutValue are the encoded value. - // The low 8 bits are 1 plus the codeLength. - int base2 = code << (7 - i); - int lutValue = (valuesPtr[x] << 8) | (2 + i); - - for (int k = 0; k < 1 << (7 - i); k++) - { - lutPtr[base2 | k] = lutValue; - } - - code++; - x++; - } - } - } - - fixed (int* minCodesPtr = this.MinCodes.Data) - fixed (int* maxCodesPtr = this.MaxCodes.Data) - fixed (int* indicesPtr = this.Indices.Data) - { - // Derive minCodes, maxCodes, and indices. - int c = 0, index = 0; - for (int i = 0; i < ncodes.Length; i++) - { - int nc = ncodes[i]; - if (nc == 0) - { - minCodesPtr[i] = -1; - maxCodesPtr[i] = -1; - indicesPtr[i] = -1; - } - else - { - minCodesPtr[i] = c; - maxCodesPtr[i] = c + nc - 1; - indicesPtr[i] = index; - c += nc; - index += nc; - } - - c <<= 1; - } - } - } - - /// - /// Gets the value for the given code and index. - /// - /// The code - /// The code length - /// The value - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public int GetValue(int code, int codeLength) - { - return this.Values[this.Indices[codeLength] + code - this.MinCodes[codeLength]]; - } - - [StructLayout(LayoutKind.Sequential)] - internal struct FixedInt32Buffer256 - { - public fixed int Data[256]; - - public int this[int idx] - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get - { - ref int self = ref Unsafe.As(ref this); - return Unsafe.Add(ref self, idx); - } - } - } - - [StructLayout(LayoutKind.Sequential)] - internal struct FixedInt32Buffer16 - { - public fixed int Data[16]; - - public int this[int idx] - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get - { - ref int self = ref Unsafe.As(ref this); - return Unsafe.Add(ref self, idx); - } - } - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangJpegScanDecoder.ComputationData.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangJpegScanDecoder.ComputationData.cs deleted file mode 100644 index f3c8aa91ba..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangJpegScanDecoder.ComputationData.cs +++ /dev/null @@ -1,53 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.Runtime.InteropServices; - -using SixLabors.ImageSharp.Formats.Jpeg.Components; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Conains the definition of - /// - internal unsafe partial struct GolangJpegScanDecoder - { - /// - /// Holds the "large" data blocks needed for computations. - /// - [StructLayout(LayoutKind.Sequential)] - public struct ComputationData - { - /// - /// The main input/working block - /// - public Block8x8 Block; - - /// - /// The jpeg unzig data - /// - public ZigZag Unzig; - - /// - /// The buffer storing the -s for each component - /// - public fixed byte ScanData[3 * GolangJpegDecoderCore.MaxComponents]; - - /// - /// The DC values for each component - /// - public fixed int Dc[GolangJpegDecoderCore.MaxComponents]; - - /// - /// Creates and initializes a new instance - /// - /// The - public static ComputationData Create() - { - ComputationData data = default; - data.Unzig = ZigZag.CreateUnzigTable(); - return data; - } - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangJpegScanDecoder.DataPointers.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangJpegScanDecoder.DataPointers.cs deleted file mode 100644 index a00da6fcaf..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangJpegScanDecoder.DataPointers.cs +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using SixLabors.ImageSharp.Formats.Jpeg.Components; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Conains the definition of - /// - internal unsafe partial struct GolangJpegScanDecoder - { - /// - /// Contains pointers to the memory regions of so they can be easily passed around to pointer based utility methods of - /// - public struct DataPointers - { - /// - /// Pointer to - /// - public Block8x8* Block; - - /// - /// Pointer to as byte* - /// - public byte* Unzig; - - /// - /// Pointer to as Scan* - /// - public GolangComponentScan* ComponentScan; - - /// - /// Pointer to - /// - public int* Dc; - - /// - /// Initializes a new instance of the struct. - /// - /// The pointer pointing to - public DataPointers(ComputationData* basePtr) - { - this.Block = &basePtr->Block; - this.Unzig = basePtr->Unzig.Data; - this.ComponentScan = (GolangComponentScan*)basePtr->ScanData; - this.Dc = basePtr->Dc; - } - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangJpegScanDecoder.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangJpegScanDecoder.cs deleted file mode 100644 index 3a88cfad4b..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/GolangJpegScanDecoder.cs +++ /dev/null @@ -1,705 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -using SixLabors.ImageSharp.Formats.Jpeg.Components; - -// ReSharper disable InconsistentNaming -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Encapsulates the impementation of Jpeg SOS Huffman decoding. See JpegScanDecoder.md! - /// - /// and are the spectral selection bounds. - /// and are the successive approximation high and low values. - /// The spec calls these values Ss, Se, Ah and Al. - /// For progressive JPEGs, these are the two more-or-less independent - /// aspects of progression. Spectral selection progression is when not - /// all of a block's 64 DCT coefficients are transmitted in one pass. - /// For example, three passes could transmit coefficient 0 (the DC - /// component), coefficients 1-5, and coefficients 6-63, in zig-zag - /// order. Successive approximation is when not all of the bits of a - /// band of coefficients are transmitted in one pass. For example, - /// three passes could transmit the 6 most significant bits, followed - /// by the second-least significant bit, followed by the least - /// significant bit. - /// For baseline JPEGs, these parameters are hard-coded to 0/63/0/0. - /// - [StructLayout(LayoutKind.Sequential)] - internal unsafe partial struct GolangJpegScanDecoder - { - // The JpegScanDecoder members should be ordered in a way that results in optimal memory layout. -#pragma warning disable SA1202 // ElementsMustBeOrderedByAccess - - /// - /// The buffer - /// - private ComputationData data; - - /// - /// Pointers to elements of - /// - private DataPointers pointers; - - /// - /// The current component index - /// - public int ComponentIndex; - - /// - /// X coordinate of the current block, in units of 8x8. (The third block in the first row has (bx, by) = (2, 0)) - /// - private int bx; - - /// - /// Y coordinate of the current block, in units of 8x8. (The third block in the first row has (bx, by) = (2, 0)) - /// - private int by; - - /// - /// Start index of the zig-zag selection bound - /// - private int zigStart; - - /// - /// End index of the zig-zag selection bound - /// - private int zigEnd; - - /// - /// Successive approximation high value - /// - private int ah; - - /// - /// Successive approximation low value - /// - private int al; - - /// - /// The number of component scans - /// - private int componentScanCount; - - /// - /// Horizontal sampling factor at the current component index - /// - private int hi; - - /// - /// End-of-Band run, specified in section G.1.2.2. - /// - private int eobRun; - - /// - /// The block counter - /// - private int blockCounter; - - /// - /// The MCU counter - /// - private int mcuCounter; - - /// - /// The expected RST marker value - /// - private byte expectedRst; - - /// - /// Initializes a default-constructed instance for reading data from -s stream. - /// - /// Pointer to on the stack - /// The instance - /// The remaining bytes in the segment block. - public static void InitStreamReading(GolangJpegScanDecoder* p, GolangJpegDecoderCore decoder, int remaining) - { - p->data = ComputationData.Create(); - p->pointers = new DataPointers(&p->data); - p->InitStreamReadingImpl(decoder, remaining); - } - - /// - /// Read Huffman data from Jpeg scans in , - /// and decode it as into . - /// - /// The blocks are traversed one MCU at a time. For 4:2:0 chroma - /// subsampling, there are four Y 8x8 blocks in every 16x16 MCU. - /// For a baseline 32x16 pixel image, the Y blocks visiting order is: - /// 0 1 4 5 - /// 2 3 6 7 - /// For progressive images, the interleaved scans (those with component count > 1) - /// are traversed as above, but non-interleaved scans are traversed left - /// to right, top to bottom: - /// 0 1 2 3 - /// 4 5 6 7 - /// Only DC scans (zigStart == 0) can be interleave AC scans must have - /// only one component. - /// To further complicate matters, for non-interleaved scans, there is no - /// data for any blocks that are inside the image at the MCU level but - /// outside the image at the pixel level. For example, a 24x16 pixel 4:2:0 - /// progressive image consists of two 16x16 MCUs. The interleaved scans - /// will process 8 Y blocks: - /// 0 1 4 5 - /// 2 3 6 7 - /// The non-interleaved scans will process only 6 Y blocks: - /// 0 1 2 - /// 3 4 5 - /// - /// The instance - public void DecodeBlocks(GolangJpegDecoderCore decoder) - { - decoder.InputProcessor.ResetErrorState(); - - this.blockCounter = 0; - this.mcuCounter = 0; - this.expectedRst = JpegConstants.Markers.RST0; - - for (int my = 0; my < decoder.MCUCountY; my++) - { - for (int mx = 0; mx < decoder.MCUCountX; mx++) - { - this.DecodeBlocksAtMcuIndex(decoder, mx, my); - - this.mcuCounter++; - - // Handling restart intervals - // Useful info: https://stackoverflow.com/a/8751802 - if (decoder.IsAtRestartInterval(this.mcuCounter)) - { - this.ProcessRSTMarker(decoder); - this.Reset(decoder); - } - } - } - } - - private void DecodeBlocksAtMcuIndex(GolangJpegDecoderCore decoder, int mx, int my) - { - for (int scanIndex = 0; scanIndex < this.componentScanCount; scanIndex++) - { - this.ComponentIndex = this.pointers.ComponentScan[scanIndex].ComponentIndex; - GolangComponent component = decoder.Components[this.ComponentIndex]; - - this.hi = component.HorizontalSamplingFactor; - int vi = component.VerticalSamplingFactor; - - for (int j = 0; j < this.hi * vi; j++) - { - if (this.componentScanCount != 1) - { - this.bx = (this.hi * mx) + (j % this.hi); - this.by = (vi * my) + (j / this.hi); - } - else - { - int q = decoder.MCUCountX * this.hi; - this.bx = this.blockCounter % q; - this.by = this.blockCounter / q; - this.blockCounter++; - if (this.bx * 8 >= decoder.ImageWidth || this.by * 8 >= decoder.ImageHeight) - { - continue; - } - } - - // Find the block at (bx,by) in the component's buffer: - ref Block8x8 blockRefOnHeap = ref component.GetBlockReference(this.bx, this.by); - - // Copy block to stack - this.data.Block = blockRefOnHeap; - - if (!decoder.InputProcessor.ReachedEOF) - { - this.DecodeBlock(decoder, scanIndex); - } - - // Store the result block: - blockRefOnHeap = this.data.Block; - } - } - } - - private void ProcessRSTMarker(GolangJpegDecoderCore decoder) - { - // Attempt to look for RST[0-7] markers to resynchronize from corrupt input. - if (!decoder.InputProcessor.ReachedEOF) - { - decoder.InputProcessor.ReadFullUnsafe(decoder.Temp, 0, 2); - if (decoder.InputProcessor.CheckEOFEnsureNoError()) - { - if (decoder.Temp[0] != 0xFF || decoder.Temp[1] != this.expectedRst) - { - bool invalidRst = true; - - // Most jpeg's containing well-formed input will have a RST[0-7] marker following immediately - // but some, see Issue #481, contain padding bytes "0xFF" before the RST[0-7] marker. - // If we identify that case we attempt to read until we have bypassed the padded bytes. - // We then check again for our RST marker and throw if invalid. - // No other methods are attempted to resynchronize from corrupt input. - if (decoder.Temp[0] == 0xFF && decoder.Temp[1] == 0xFF) - { - while (decoder.Temp[0] == 0xFF && decoder.InputProcessor.CheckEOFEnsureNoError()) - { - decoder.InputProcessor.ReadFullUnsafe(decoder.Temp, 0, 1); - if (!decoder.InputProcessor.CheckEOFEnsureNoError()) - { - break; - } - } - - // Have we found a valid restart marker? - invalidRst = decoder.Temp[0] != this.expectedRst; - } - - if (invalidRst) - { - throw new ImageFormatException("Bad RST marker"); - } - } - - this.expectedRst++; - if (this.expectedRst == JpegConstants.Markers.RST7 + 1) - { - this.expectedRst = JpegConstants.Markers.RST0; - } - } - } - } - - private void Reset(GolangJpegDecoderCore decoder) - { - decoder.InputProcessor.ResetHuffmanDecoder(); - - this.ResetDcValues(); - - // Reset the progressive decoder state, as per section G.1.2.2. - this.eobRun = 0; - } - - /// - /// Reset the DC components, as per section F.2.1.3.1. - /// - private void ResetDcValues() - { - Unsafe.InitBlock(this.pointers.Dc, default, sizeof(int) * GolangJpegDecoderCore.MaxComponents); - } - - /// - /// The implementation part of as an instance method. - /// - /// The - /// The remaining bytes - private void InitStreamReadingImpl(GolangJpegDecoderCore decoder, int remaining) - { - if (decoder.ComponentCount == 0) - { - throw new ImageFormatException("Missing SOF marker"); - } - - if (remaining < 6 || 4 + (2 * decoder.ComponentCount) < remaining || remaining % 2 != 0) - { - throw new ImageFormatException("SOS has wrong length"); - } - - decoder.InputProcessor.ReadFull(decoder.Temp, 0, remaining); - this.componentScanCount = decoder.Temp[0]; - - int scanComponentCountX2 = 2 * this.componentScanCount; - if (remaining != 4 + scanComponentCountX2) - { - throw new ImageFormatException("SOS length inconsistent with number of components"); - } - - int totalHv = 0; - - for (int i = 0; i < this.componentScanCount; i++) - { - this.InitComponentScan(decoder, i, ref this.pointers.ComponentScan[i], ref totalHv); - } - - // Section B.2.3 states that if there is more than one component then the - // total H*V values in a scan must be <= 10. - if (decoder.ComponentCount > 1 && totalHv > 10) - { - throw new ImageFormatException("Total sampling factors too large."); - } - - this.zigEnd = Block8x8F.Size - 1; - - if (decoder.IsProgressive) - { - this.zigStart = decoder.Temp[1 + scanComponentCountX2]; - this.zigEnd = decoder.Temp[2 + scanComponentCountX2]; - this.ah = decoder.Temp[3 + scanComponentCountX2] >> 4; - this.al = decoder.Temp[3 + scanComponentCountX2] & 0x0f; - - if ((this.zigStart == 0 && this.zigEnd != 0) || this.zigStart > this.zigEnd - || this.zigEnd >= Block8x8F.Size) - { - throw new ImageFormatException("Bad spectral selection bounds"); - } - - if (this.zigStart != 0 && this.componentScanCount != 1) - { - throw new ImageFormatException("Progressive AC coefficients for more than one component"); - } - - if (this.ah != 0 && this.ah != this.al + 1) - { - throw new ImageFormatException("Bad successive approximation values"); - } - } - } - - /// - /// Read the current the current block at (, ) from the decoders stream - /// - /// The decoder - /// The index of the scan - private void DecodeBlock(GolangJpegDecoderCore decoder, int scanIndex) - { - Block8x8* b = this.pointers.Block; - int huffmannIdx = (GolangHuffmanTree.AcTableIndex * GolangHuffmanTree.ThRowSize) + this.pointers.ComponentScan[scanIndex].AcTableSelector; - if (this.ah != 0) - { - this.Refine(ref decoder.InputProcessor, ref decoder.HuffmanTrees[huffmannIdx], 1 << this.al); - } - else - { - int zig = this.zigStart; - - if (zig == 0) - { - zig++; - - // Decode the DC coefficient, as specified in section F.2.2.1. - int huffmanIndex = (GolangHuffmanTree.DcTableIndex * GolangHuffmanTree.ThRowSize) + this.pointers.ComponentScan[scanIndex].DcTableSelector; - decoder.InputProcessor.DecodeHuffmanUnsafe( - ref decoder.HuffmanTrees[huffmanIndex], - out int value); - if (!decoder.InputProcessor.CheckEOF()) - { - return; - } - - if (value > 16) - { - throw new ImageFormatException("Excessive DC component"); - } - - decoder.InputProcessor.ReceiveExtendUnsafe(value, out int deltaDC); - if (!decoder.InputProcessor.CheckEOFEnsureNoError()) - { - return; - } - - this.pointers.Dc[this.ComponentIndex] += deltaDC; - - // b[0] = dc[compIndex] << al; - value = this.pointers.Dc[this.ComponentIndex] << this.al; - Block8x8.SetScalarAt(b, 0, (short)value); - } - - if (zig <= this.zigEnd && this.eobRun > 0) - { - this.eobRun--; - } - else - { - // Decode the AC coefficients, as specified in section F.2.2.2. - for (; zig <= this.zigEnd; zig++) - { - decoder.InputProcessor.DecodeHuffmanUnsafe(ref decoder.HuffmanTrees[huffmannIdx], out int value); - if (decoder.InputProcessor.HasError) - { - return; - } - - int val0 = value >> 4; - int val1 = value & 0x0f; - if (val1 != 0) - { - zig += val0; - if (zig > this.zigEnd) - { - break; - } - - decoder.InputProcessor.ReceiveExtendUnsafe(val1, out int ac); - if (decoder.InputProcessor.HasError) - { - return; - } - - // b[Unzig[zig]] = ac << al; - value = ac << this.al; - Block8x8.SetScalarAt(b, this.pointers.Unzig[zig], (short)value); - } - else - { - if (val0 != 0x0f) - { - this.eobRun = (ushort)(1 << val0); - if (val0 != 0) - { - this.DecodeEobRun(val0, ref decoder.InputProcessor); - if (!decoder.InputProcessor.CheckEOFEnsureNoError()) - { - return; - } - } - - this.eobRun--; - break; - } - - zig += 0x0f; - } - } - } - } - } - - private void DecodeEobRun(int count, ref InputProcessor processor) - { - processor.DecodeBitsUnsafe(count, out int bitsResult); - if (processor.LastErrorCode != GolangDecoderErrorCode.NoError) - { - return; - } - - this.eobRun |= bitsResult; - } - - private void InitComponentScan(GolangJpegDecoderCore decoder, int i, ref GolangComponentScan currentComponentScan, ref int totalHv) - { - // Component selector. - int cs = decoder.Temp[1 + (2 * i)]; - int compIndex = -1; - for (int j = 0; j < decoder.ComponentCount; j++) - { - // Component compv = ; - if (cs == decoder.Components[j].Identifier) - { - compIndex = j; - } - } - - if (compIndex < 0) - { - throw new ImageFormatException("Unknown component selector"); - } - - currentComponentScan.ComponentIndex = (byte)compIndex; - - this.ProcessComponentImpl(decoder, i, ref currentComponentScan, ref totalHv, decoder.Components[compIndex]); - } - - private void ProcessComponentImpl( - GolangJpegDecoderCore decoder, - int i, - ref GolangComponentScan currentComponentScan, - ref int totalHv, - GolangComponent currentComponent) - { - // Section B.2.3 states that "the value of Cs_j shall be different from - // the values of Cs_1 through Cs_(j-1)". Since we have previously - // verified that a frame's component identifiers (C_i values in section - // B.2.2) are unique, it suffices to check that the implicit indexes - // into comp are unique. - for (int j = 0; j < i; j++) - { - if (currentComponentScan.ComponentIndex == this.pointers.ComponentScan[j].ComponentIndex) - { - throw new ImageFormatException("Repeated component selector"); - } - } - - totalHv += currentComponent.HorizontalSamplingFactor * currentComponent.VerticalSamplingFactor; - - currentComponentScan.DcTableSelector = (byte)(decoder.Temp[2 + (2 * i)] >> 4); - if (currentComponentScan.DcTableSelector > GolangHuffmanTree.MaxTh) - { - throw new ImageFormatException("Bad DC table selector value"); - } - - currentComponentScan.AcTableSelector = (byte)(decoder.Temp[2 + (2 * i)] & 0x0f); - if (currentComponentScan.AcTableSelector > GolangHuffmanTree.MaxTh) - { - throw new ImageFormatException("Bad AC table selector value"); - } - } - - /// - /// Decodes a successive approximation refinement block, as specified in section G.1.2. - /// - /// The instance - /// The Huffman tree - /// The low transform offset - private void Refine(ref InputProcessor bp, ref GolangHuffmanTree h, int delta) - { - Block8x8* b = this.pointers.Block; - - // Refining a DC component is trivial. - if (this.zigStart == 0) - { - if (this.zigEnd != 0) - { - throw new ImageFormatException("Invalid state for zig DC component"); - } - - bp.DecodeBitUnsafe(out bool bit); - if (!bp.CheckEOFEnsureNoError()) - { - return; - } - - if (bit) - { - int stuff = Block8x8.GetScalarAt(b, 0); - - // int stuff = (int)b[0]; - stuff |= delta; - - // b[0] = stuff; - Block8x8.SetScalarAt(b, 0, (short)stuff); - } - - return; - } - - // Refining AC components is more complicated; see sections G.1.2.2 and G.1.2.3. - int zig = this.zigStart; - if (this.eobRun == 0) - { - for (; zig <= this.zigEnd; zig++) - { - bool done = false; - int z = 0; - - bp.DecodeHuffmanUnsafe(ref h, out int val); - if (!bp.CheckEOF()) - { - return; - } - - int val0 = val >> 4; - int val1 = val & 0x0f; - - switch (val1) - { - case 0: - if (val0 != 0x0f) - { - this.eobRun = 1 << val0; - if (val0 != 0) - { - this.DecodeEobRun(val0, ref bp); - if (!bp.CheckEOFEnsureNoError()) - { - return; - } - } - - done = true; - } - - break; - case 1: - z = delta; - - bp.DecodeBitUnsafe(out bool bit); - if (!bp.CheckEOFEnsureNoError()) - { - return; - } - - if (!bit) - { - z = -z; - } - - break; - default: - throw new ImageFormatException("Unexpected Huffman code"); - } - - if (done) - { - break; - } - - zig = this.RefineNonZeroes(ref bp, zig, val0, delta); - - if (bp.ReachedEOF || bp.HasError) - { - return; - } - - if (z != 0 && zig <= this.zigEnd) - { - // b[Unzig[zig]] = z; - Block8x8.SetScalarAt(b, this.pointers.Unzig[zig], (short)z); - } - } - } - - if (this.eobRun > 0) - { - this.eobRun--; - this.RefineNonZeroes(ref bp, zig, -1, delta); - } - } - - /// - /// Refines non-zero entries of b in zig-zag order. - /// If >= 0, the first zero entries are skipped over. - /// - /// The - /// The zig-zag start index - /// The non-zero entry - /// The low transform offset - /// The - private int RefineNonZeroes(ref InputProcessor bp, int zig, int nz, int delta) - { - Block8x8* b = this.pointers.Block; - for (; zig <= this.zigEnd; zig++) - { - int u = this.pointers.Unzig[zig]; - int bu = Block8x8.GetScalarAt(b, u); - - // TODO: Are the equality comparsions OK with floating point values? Isn't an epsilon value necessary? - if (bu == 0) - { - if (nz == 0) - { - break; - } - - nz--; - continue; - } - - bp.DecodeBitUnsafe(out bool bit); - if (bp.HasError) - { - return int.MinValue; - } - - if (!bit) - { - continue; - } - - int val = bu >= 0 ? bu + delta : bu - delta; - - Block8x8.SetScalarAt(b, u, (short)val); - } - - return zig; - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/InputProcessor.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/InputProcessor.cs deleted file mode 100644 index c7e14ee4f2..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/InputProcessor.cs +++ /dev/null @@ -1,392 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; -using System.IO; -using System.Runtime.CompilerServices; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// Encapsulates stream reading and processing data and operations for . - /// It's a value type for imporved data locality, and reduced number of CALLVIRT-s - /// - internal struct InputProcessor : IDisposable - { - /// - /// Holds the unprocessed bits that have been taken from the byte-stream. - /// - public Bits Bits; - - /// - /// The byte buffer - /// - public Bytes Bytes; - - /// - /// Initializes a new instance of the struct. - /// - /// The input - /// Temporal buffer, same as - public InputProcessor(Stream inputStream, byte[] temp) - { - this.Bits = default; - this.Bytes = Bytes.Create(); - this.InputStream = inputStream; - this.Temp = temp; - this.LastErrorCode = GolangDecoderErrorCode.NoError; - } - - /// - /// Gets the input stream - /// - public Stream InputStream { get; } - - /// - /// Gets the temporary buffer, same instance as - /// - public byte[] Temp { get; } - - /// - /// Gets a value indicating whether an unexpected EOF reached in . - /// - public bool ReachedEOF => this.LastErrorCode == GolangDecoderErrorCode.UnexpectedEndOfStream; - - public bool HasError => this.LastErrorCode != GolangDecoderErrorCode.NoError; - - public GolangDecoderErrorCode LastErrorCode { get; private set; } - - public void ResetErrorState() => this.LastErrorCode = GolangDecoderErrorCode.NoError; - - /// - /// If errorCode indicates unexpected EOF, sets to true and returns false. - /// Calls and returns true otherwise. - /// - /// A indicating whether EOF reached - public bool CheckEOFEnsureNoError() - { - if (this.LastErrorCode == GolangDecoderErrorCode.UnexpectedEndOfStream) - { - return false; - } - - this.LastErrorCode.EnsureNoError(); - return true; - } - - /// - /// If errorCode indicates unexpected EOF, sets to true and returns false. - /// Returns true otherwise. - /// - /// A indicating whether EOF reached - public bool CheckEOF() - { - if (this.LastErrorCode == GolangDecoderErrorCode.UnexpectedEndOfStream) - { - return false; - } - - return true; - } - - /// - public void Dispose() - { - this.Bytes.Dispose(); - } - - /// - /// Returns the next byte, whether buffered or not buffered. It does not care about byte stuffing. - /// - /// The - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public byte ReadByte() - { - return this.Bytes.ReadByte(this.InputStream); - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public GolangDecoderErrorCode ReadByteUnsafe(out byte result) - { - this.LastErrorCode = this.Bytes.ReadByteUnsafe(this.InputStream, out result); - return this.LastErrorCode; - } - - /// - /// Decodes a single bit - /// TODO: This method (and also the usages) could be optimized by batching! - /// - /// The decoded bit as a - /// The - public GolangDecoderErrorCode DecodeBitUnsafe(out bool result) - { - if (this.Bits.UnreadBits == 0) - { - this.LastErrorCode = this.Bits.Ensure1BitUnsafe(ref this); - if (this.LastErrorCode != GolangDecoderErrorCode.NoError) - { - result = false; - return this.LastErrorCode; - } - } - - result = (this.Bits.Accumulator & this.Bits.Mask) != 0; - this.Bits.UnreadBits--; - this.Bits.Mask >>= 1; - return this.LastErrorCode = GolangDecoderErrorCode.NoError; - } - - /// - /// Reads exactly length bytes into data. It does not care about byte stuffing. - /// Does not throw on errors, returns instead! - /// - /// The data to write to. - /// The offset in the source buffer - /// The number of bytes to read - /// The - public GolangDecoderErrorCode ReadFullUnsafe(byte[] data, int offset, int length) - { - // Unread the overshot bytes, if any. - if (this.Bytes.UnreadableBytes != 0) - { - if (this.Bits.UnreadBits >= 8) - { - this.UnreadByteStuffedByte(); - } - - this.Bytes.UnreadableBytes = 0; - } - - this.LastErrorCode = GolangDecoderErrorCode.NoError; - while (length > 0 && this.LastErrorCode == GolangDecoderErrorCode.NoError) - { - if (this.Bytes.J - this.Bytes.I >= length) - { - Array.Copy(this.Bytes.Buffer, this.Bytes.I, data, offset, length); - this.Bytes.I += length; - length -= length; - } - else - { - Array.Copy(this.Bytes.Buffer, this.Bytes.I, data, offset, this.Bytes.J - this.Bytes.I); - offset += this.Bytes.J - this.Bytes.I; - length -= this.Bytes.J - this.Bytes.I; - this.Bytes.I += this.Bytes.J - this.Bytes.I; - - this.LastErrorCode = this.Bytes.FillUnsafe(this.InputStream); - } - } - - return this.LastErrorCode; - } - - /// - /// Decodes the given number of bits - /// - /// The number of bits to decode. - /// The result - /// The - public GolangDecoderErrorCode DecodeBitsUnsafe(int count, out int result) - { - if (this.Bits.UnreadBits < count) - { - this.LastErrorCode = this.Bits.EnsureNBitsUnsafe(count, ref this); - if (this.LastErrorCode != GolangDecoderErrorCode.NoError) - { - result = 0; - return this.LastErrorCode; - } - } - - result = this.Bits.Accumulator >> (this.Bits.UnreadBits - count); - result = result & ((1 << count) - 1); - this.Bits.UnreadBits -= count; - this.Bits.Mask >>= count; - return this.LastErrorCode = GolangDecoderErrorCode.NoError; - } - - /// - /// Extracts the next Huffman-coded value from the bit-stream into result, decoded according to the given value. - /// - /// The huffman value - /// The decoded - /// The - public GolangDecoderErrorCode DecodeHuffmanUnsafe(ref GolangHuffmanTree huffmanTree, out int result) - { - result = 0; - - if (huffmanTree.Length == 0) - { - DecoderThrowHelper.ThrowImageFormatException.UninitializedHuffmanTable(); - } - - if (this.Bits.UnreadBits < 8) - { - this.LastErrorCode = this.Bits.Ensure8BitsUnsafe(ref this); - - if (this.LastErrorCode == GolangDecoderErrorCode.NoError) - { - int lutIndex = (this.Bits.Accumulator >> (this.Bits.UnreadBits - GolangHuffmanTree.LutSizeLog2)) & 0xFF; - int v = huffmanTree.Lut[lutIndex]; - - if (v != 0) - { - int n = (v & 0xFF) - 1; - this.Bits.UnreadBits -= n; - this.Bits.Mask >>= n; - result = v >> 8; - return this.LastErrorCode; - } - } - else - { - this.UnreadByteStuffedByte(); - return this.LastErrorCode; - } - } - - int code = 0; - for (int i = 0; i < GolangHuffmanTree.MaxCodeLength; i++) - { - if (this.Bits.UnreadBits == 0) - { - this.LastErrorCode = this.Bits.EnsureNBitsUnsafe(1, ref this); - - if (this.HasError) - { - return this.LastErrorCode; - } - } - - if ((this.Bits.Accumulator & this.Bits.Mask) != 0) - { - code |= 1; - } - - this.Bits.UnreadBits--; - this.Bits.Mask >>= 1; - - if (code <= huffmanTree.MaxCodes[i]) - { - result = huffmanTree.GetValue(code, i); - return this.LastErrorCode = GolangDecoderErrorCode.NoError; - } - - code <<= 1; - } - - // Unrecoverable error, throwing: - DecoderThrowHelper.ThrowImageFormatException.BadHuffmanCode(); - - // DUMMY RETURN! C# doesn't know we have thrown an exception! - return GolangDecoderErrorCode.NoError; - } - - /// - /// Skips the next n bytes. - /// - /// The number of bytes to ignore. - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void Skip(int count) - { - this.LastErrorCode = this.SkipUnsafe(count); - this.LastErrorCode.EnsureNoError(); - } - - /// - /// Skips the next n bytes. - /// Does not throw, returns instead! - /// - /// The number of bytes to ignore. - /// The - public GolangDecoderErrorCode SkipUnsafe(int count) - { - // Unread the overshot bytes, if any. - if (this.Bytes.UnreadableBytes != 0) - { - if (this.Bits.UnreadBits >= 8) - { - this.UnreadByteStuffedByte(); - } - - this.Bytes.UnreadableBytes = 0; - } - - while (true) - { - int m = this.Bytes.J - this.Bytes.I; - if (m > count) - { - m = count; - } - - this.Bytes.I += m; - count -= m; - if (count == 0) - { - break; - } - - this.LastErrorCode = this.Bytes.FillUnsafe(this.InputStream); - if (this.LastErrorCode != GolangDecoderErrorCode.NoError) - { - return this.LastErrorCode; - } - } - - return this.LastErrorCode = GolangDecoderErrorCode.NoError; - } - - /// - /// Reads exactly length bytes into data. It does not care about byte stuffing. - /// - /// The data to write to. - /// The offset in the source buffer - /// The number of bytes to read - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void ReadFull(byte[] data, int offset, int length) - { - this.LastErrorCode = this.ReadFullUnsafe(data, offset, length); - this.LastErrorCode.EnsureNoError(); - } - - /// - /// Undoes the most recent ReadByteStuffedByte call, - /// giving a byte of data back from bits to bytes. The Huffman look-up table - /// requires at least 8 bits for look-up, which means that Huffman decoding can - /// sometimes overshoot and read one or two too many bytes. Two-byte overshoot - /// can happen when expecting to read a 0xff 0x00 byte-stuffed byte. - /// - public void UnreadByteStuffedByte() - { - this.Bytes.I -= this.Bytes.UnreadableBytes; - this.Bytes.UnreadableBytes = 0; - if (this.Bits.UnreadBits >= 8) - { - this.Bits.Accumulator >>= 8; - this.Bits.UnreadBits -= 8; - this.Bits.Mask >>= 8; - } - } - - /// - /// Receive extend - /// - /// Byte - /// Read bits value - /// The - public GolangDecoderErrorCode ReceiveExtendUnsafe(int t, out int x) - { - this.LastErrorCode = this.Bits.ReceiveExtendUnsafe(t, ref this, out x); - return this.LastErrorCode; - } - - /// - /// Reset the Huffman decoder. - /// - public void ResetHuffmanDecoder() - { - this.Bits = default; - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/JpegScanDecoder.md b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/JpegScanDecoder.md deleted file mode 100644 index 4ca4d1f642..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/JpegScanDecoder.md +++ /dev/null @@ -1,25 +0,0 @@ -## JpegScanDecoder -Encapsulates the impementation of the Jpeg top-to bottom scan decoder triggered by the `SOS` marker. -The implementation is optimized to hold most of the necessary data in a single value type, which is intended to be used as an on-stack object. - -#### Benefits: -- Maximized locality of reference by keeping most of the operation data on the stack -- Achieving this without long parameter lists, most of the values describing the state of the decoder algorithm -are members of the `JpegScanDecoder` struct -- Most of the logic related to Scan decoding is refactored & simplified now to live in the methods of `JpegScanDecoder` -- The first step is done towards separating the stream reading from block processing. They can be refactored later to be executed in two disctinct loops. - - The input processing loop can be `async` - - The block processing loop can be parallelized - -#### Data layout - -|JpegScanDecoder | -|-------------------| -|Variables | -|DataPointers | -|ComputationData | - -- **ComputationData** holds the "large" data blocks needed for computations (Mostly `Block8x8F`-s) -- **DataPointers** contains pointers to the memory regions of `ComponentData` so they can be easily passed around to pointer based utility methods of `Block8x8F` - - diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/MissingFF00Exception.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/MissingFF00Exception.cs deleted file mode 100644 index 005034b9dc..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/MissingFF00Exception.cs +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder -{ - /// - /// The missing ff00 exception. - /// - // ReSharper disable once InconsistentNaming - internal class MissingFF00Exception : Exception - { - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/GolangJpegDecoder.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/GolangJpegDecoder.cs deleted file mode 100644 index 29255204b4..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/GolangJpegDecoder.cs +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.IO; -using SixLabors.ImageSharp.PixelFormats; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort -{ - /// - /// Image decoder for generating an image out of a jpg stream. - /// - internal sealed class GolangJpegDecoder : IImageDecoder, IJpegDecoderOptions, IImageInfoDetector - { - /// - /// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded. - /// - public bool IgnoreMetadata { get; set; } - - /// - public Image Decode(Configuration configuration, Stream stream) - where TPixel : struct, IPixel - { - Guard.NotNull(stream, nameof(stream)); - - using (var decoder = new GolangJpegDecoderCore(configuration, this)) - { - return decoder.Decode(stream); - } - } - - /// - public IImageInfo Identify(Configuration configuration, Stream stream) - { - Guard.NotNull(stream, nameof(stream)); - - using (var decoder = new GolangJpegDecoderCore(configuration, this)) - { - return decoder.Identify(stream); - } - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/GolangJpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/GolangJpegDecoderCore.cs deleted file mode 100644 index 46cdcddb45..0000000000 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/GolangJpegDecoderCore.cs +++ /dev/null @@ -1,824 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.Collections.Generic; -using System.IO; - -using SixLabors.ImageSharp.Formats.Jpeg.Components; -using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder; -using SixLabors.ImageSharp.MetaData; -using SixLabors.ImageSharp.MetaData.Profiles.Exif; -using SixLabors.ImageSharp.MetaData.Profiles.Icc; -using SixLabors.ImageSharp.PixelFormats; -using SixLabors.ImageSharp.Primitives; -using SixLabors.Primitives; - -namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort -{ - /// - /// - /// Performs the jpeg decoding operation. - /// - internal sealed unsafe class GolangJpegDecoderCore : IRawJpegData - { - /// - /// The maximum number of color components - /// - public const int MaxComponents = 4; - - /// - /// The maximum number of quantization tables - /// - public const int MaxTq = 3; - - /// - /// The only supported precision - /// - public const int SupportedPrecision = 8; - - // Complex value type field + mutable + available to other classes = the field MUST NOT be private :P -#pragma warning disable SA1401 // FieldsMustBePrivate - - /// - /// Encapsulates stream reading and processing data and operations for . - /// It's a value type for improved data locality, and reduced number of CALLVIRT-s - /// - public InputProcessor InputProcessor; -#pragma warning restore SA401 - - /// - /// The global configuration - /// - private readonly Configuration configuration; - - /// - /// Whether the image has a JFIF header - /// It's faster to check this than to use the equality operator on the struct - /// - private bool isJFif; - - /// - /// Contains information about the JFIF marker - /// - private JFifMarker jFif; - - /// - /// Whether the image has a EXIF header - /// - private bool isExif; - - /// - /// Whether the image has an Adobe marker. - /// It's faster to check this than to use the equality operator on the struct - /// - private bool isAdobe; - - /// - /// Contains information about the Adobe marker - /// - private AdobeMarker adobe; - - /// - /// Initializes a new instance of the class. - /// - /// The configuration. - /// The options. - public GolangJpegDecoderCore(Configuration configuration, IJpegDecoderOptions options) - { - this.IgnoreMetadata = options.IgnoreMetadata; - this.configuration = configuration ?? Configuration.Default; - this.Temp = new byte[2 * Block8x8F.Size]; - } - - /// - public JpegColorSpace ColorSpace { get; private set; } - - /// - /// Gets the component array - /// - public GolangComponent[] Components { get; private set; } - - /// - /// Gets the huffman trees - /// - public GolangHuffmanTree[] HuffmanTrees { get; private set; } - - /// - public Block8x8F[] QuantizationTables { get; private set; } - - /// - /// Gets the temporary buffer used to store bytes read from the stream. - /// TODO: Should be stack allocated, fixed sized buffer! - /// - public byte[] Temp { get; } - - /// - public Size ImageSizeInPixels { get; private set; } - - /// - /// Gets the number of MCU blocks in the image as . - /// - public Size ImageSizeInMCU { get; private set; } - - /// - public int ComponentCount { get; private set; } - - IEnumerable IRawJpegData.Components => this.Components; - - /// - /// Gets the color depth, in number of bits per pixel. - /// - public int BitsPerPixel => this.ComponentCount * SupportedPrecision; - - /// - /// Gets the image height - /// - public int ImageHeight => this.ImageSizeInPixels.Height; - - /// - /// Gets the image width - /// - public int ImageWidth => this.ImageSizeInPixels.Width; - - /// - /// Gets the input stream. - /// - public Stream InputStream { get; private set; } - - /// - /// Gets a value indicating whether the image is interlaced (progressive) - /// - public bool IsProgressive { get; private set; } - - /// - /// Gets the restart interval - /// - public int RestartInterval { get; private set; } - - /// - /// Gets the number of MCU-s (Minimum Coded Units) in the image along the X axis - /// - public int MCUCountX => this.ImageSizeInMCU.Width; - - /// - /// Gets the number of MCU-s (Minimum Coded Units) in the image along the Y axis - /// - public int MCUCountY => this.ImageSizeInMCU.Height; - - /// - /// Gets the total number of MCU-s (Minimum Coded Units) in the image. - /// - public int TotalMCUCount => this.MCUCountX * this.MCUCountY; - - /// - /// Gets a value indicating whether the metadata should be ignored when the image is being decoded. - /// - public bool IgnoreMetadata { get; } - - /// - /// Gets the decoded by this decoder instance. - /// - public ImageMetaData MetaData { get; private set; } - - /// - /// Decodes the image from the specified and sets - /// the data to image. - /// - /// The pixel format. - /// The stream, where the image should be. - /// The decoded image. - public Image Decode(Stream stream) - where TPixel : struct, IPixel - { - this.ParseStream(stream); - return this.PostProcessIntoImage(); - } - - /// - /// Reads the raw image information from the specified stream. - /// - /// The containing image data. - public IImageInfo Identify(Stream stream) - { - this.ParseStream(stream, true); - return new ImageInfo(new PixelTypeInfo(this.BitsPerPixel), this.ImageWidth, this.ImageHeight, this.MetaData); - } - - /// - public void Dispose() - { - if (this.Components != null) - { - foreach (GolangComponent component in this.Components) - { - component?.Dispose(); - } - } - - this.InputProcessor.Dispose(); - } - - /// - /// Read metadata from stream and read the blocks in the scans into . - /// - /// The stream - /// Whether to decode metadata only. - public void ParseStream(Stream stream, bool metadataOnly = false) - { - this.MetaData = new ImageMetaData(); - this.InputStream = stream; - this.InputProcessor = new InputProcessor(stream, this.Temp); - - if (!metadataOnly) - { - this.HuffmanTrees = GolangHuffmanTree.CreateHuffmanTrees(); - this.QuantizationTables = new Block8x8F[MaxTq + 1]; - } - - // Check for the Start Of Image marker. - this.InputProcessor.ReadFull(this.Temp, 0, 2); - - if (this.Temp[0] != JpegConstants.Markers.XFF || this.Temp[1] != JpegConstants.Markers.SOI) - { - throw new ImageFormatException("Missing SOI marker."); - } - - // Process the remaining segments until the End Of Image marker. - bool processBytes = true; - - // we can't currently short circute progressive images so don't try. - while (processBytes) - { - this.InputProcessor.ReadFull(this.Temp, 0, 2); - - if (this.InputProcessor.ReachedEOF) - { - // We've reached the end of the stream. - processBytes = false; - } - - while (this.Temp[0] != 0xff) - { - // Strictly speaking, this is a format error. However, libjpeg is - // liberal in what it accepts. As of version 9, next_marker in - // jdmarker.c treats this as a warning (JWRN_EXTRANEOUS_DATA) and - // continues to decode the stream. Even before next_marker sees - // extraneous data, jpeg_fill_bit_buffer in jdhuff.c reads as many - // bytes as it can, possibly past the end of a scan's data. It - // effectively puts back any markers that it overscanned (e.g. an - // "\xff\xd9" EOI marker), but it does not put back non-marker data, - // and thus it can silently ignore a small number of extraneous - // non-marker bytes before next_marker has a chance to see them (and - // print a warning). - // We are therefore also liberal in what we accept. Extraneous data - // is silently ignore - // This is similar to, but not exactly the same as, the restart - // mechanism within a scan (the RST[0-7] markers). - // Note that extraneous 0xff bytes in e.g. SOS data are escaped as - // "\xff\x00", and so are detected a little further down below. - this.Temp[0] = this.Temp[1]; - this.Temp[1] = this.InputProcessor.ReadByte(); - } - - byte marker = this.Temp[1]; - if (marker == 0) - { - // Treat "\xff\x00" as extraneous data. - continue; - } - - while (marker == 0xff) - { - // Section B.1.1.2 says, "Any marker may optionally be preceded by any - // number of fill bytes, which are bytes assigned code X'FF'". - this.InputProcessor.ReadByteUnsafe(out marker); - - if (this.InputProcessor.ReachedEOF) - { - // We've reached the end of the stream. - processBytes = false; - break; - } - } - - // End Of Image. - if (marker == JpegConstants.Markers.EOI) - { - break; - } - - if (marker >= JpegConstants.Markers.RST0 && marker <= JpegConstants.Markers.RST7) - { - // Figures B.2 and B.16 of the specification suggest that restart markers should - // only occur between Entropy Coded Segments and not after the final ECS. - // However, some encoders may generate incorrect JPEGs with a final restart - // marker. That restart marker will be seen here instead of inside the ProcessSOS - // method, and is ignored as a harmless error. Restart markers have no extra data, - // so we check for this before we read the 16-bit length of the segment. - continue; - } - - // Read the 16-bit length of the segment. The value includes the 2 bytes for the - // length itself, so we subtract 2 to get the number of remaining bytes. - this.InputProcessor.ReadFullUnsafe(this.Temp, 0, 2); - int remaining = (this.Temp[0] << 8) + this.Temp[1] - 2; - if (remaining < 0) - { - throw new ImageFormatException("Short segment length."); - } - - switch (marker) - { - case JpegConstants.Markers.SOF0: - case JpegConstants.Markers.SOF1: - case JpegConstants.Markers.SOF2: - this.IsProgressive = marker == JpegConstants.Markers.SOF2; - this.ProcessStartOfFrameMarker(remaining, metadataOnly); - - break; - case JpegConstants.Markers.DHT: - - if (metadataOnly) - { - this.InputProcessor.Skip(remaining); - } - else - { - this.ProcessDefineHuffmanTablesMarker(remaining); - } - - break; - case JpegConstants.Markers.DQT: - if (metadataOnly) - { - this.InputProcessor.Skip(remaining); - } - else - { - this.ProcessDefineQuantizationTablesMarker(remaining); - } - - break; - case JpegConstants.Markers.SOS: - if (!metadataOnly) - { - this.ProcessStartOfScanMarker(remaining); - if (this.InputProcessor.ReachedEOF) - { - // If unexpected EOF reached. We can stop processing bytes as we now have the image data. - processBytes = false; - } - } - else - { - // It's highly unlikely that APPn related data will be found after the SOS marker - // We should have gathered everything we need by now. - processBytes = false; - } - - break; - - case JpegConstants.Markers.DRI: - if (metadataOnly) - { - this.InputProcessor.Skip(remaining); - } - else - { - this.ProcessDefineRestartIntervalMarker(remaining); - } - - break; - case JpegConstants.Markers.APP0: - this.ProcessApplicationHeaderMarker(remaining); - break; - case JpegConstants.Markers.APP1: - this.ProcessApp1Marker(remaining); - break; - case JpegConstants.Markers.APP2: - this.ProcessApp2Marker(remaining); - break; - case JpegConstants.Markers.APP14: - this.ProcessApp14Marker(remaining); - break; - default: - if ((marker >= JpegConstants.Markers.APP0 && marker <= JpegConstants.Markers.APP15) - || marker == JpegConstants.Markers.COM) - { - this.InputProcessor.Skip(remaining); - } - - break; - } - } - - this.InitDerivedMetaDataProperties(); - } - - /// - /// Returns true if 'mcuCounter' is at restart interval - /// - public bool IsAtRestartInterval(int mcuCounter) - { - return this.RestartInterval > 0 && mcuCounter % this.RestartInterval == 0 - && mcuCounter < this.TotalMCUCount; - } - - /// - /// Assigns derived metadata properties to , eg. horizontal and vertical resolution if it has a JFIF header. - /// - private void InitDerivedMetaDataProperties() - { - if (this.isJFif) - { - this.MetaData.HorizontalResolution = this.jFif.XDensity; - this.MetaData.VerticalResolution = this.jFif.YDensity; - } - else if (this.isExif) - { - double horizontalValue = this.MetaData.ExifProfile.TryGetValue(ExifTag.XResolution, out ExifValue horizonalTag) - ? ((Rational)horizonalTag.Value).ToDouble() - : 0; - - double verticalValue = this.MetaData.ExifProfile.TryGetValue(ExifTag.YResolution, out ExifValue verticalTag) - ? ((Rational)verticalTag.Value).ToDouble() - : 0; - - if (horizontalValue > 0 && verticalValue > 0) - { - this.MetaData.HorizontalResolution = horizontalValue; - this.MetaData.VerticalResolution = verticalValue; - } - } - - if (this.MetaData.IccProfile?.CheckIsValid() == false) - { - this.MetaData.IccProfile = null; - } - } - - /// - /// Processes the application header containing the JFIF identifier plus extra data. - /// - /// The remaining bytes in the segment block. - private void ProcessApplicationHeaderMarker(int remaining) - { - if (remaining < 5) - { - this.InputProcessor.Skip(remaining); - return; - } - - const int MarkerLength = JFifMarker.Length; - this.InputProcessor.ReadFull(this.Temp, 0, MarkerLength); - remaining -= MarkerLength; - - this.isJFif = JFifMarker.TryParse(this.Temp, out this.jFif); - - if (remaining > 0) - { - this.InputProcessor.Skip(remaining); - } - } - - /// - /// Processes the App1 marker retrieving any stored metadata - /// - /// The remaining bytes in the segment block. - private void ProcessApp1Marker(int remaining) - { - if (remaining < 6 || this.IgnoreMetadata) - { - this.InputProcessor.Skip(remaining); - return; - } - - byte[] profile = new byte[remaining]; - this.InputProcessor.ReadFull(profile, 0, remaining); - - if (ProfileResolver.IsProfile(profile, ProfileResolver.ExifMarker)) - { - this.isExif = true; - this.MetaData.ExifProfile = new ExifProfile(profile); - } - } - - /// - /// Processes the App2 marker retrieving any stored ICC profile information - /// - /// The remaining bytes in the segment block. - private void ProcessApp2Marker(int remaining) - { - // Length is 14 though we only need to check 12. - const int Icclength = 14; - if (remaining < Icclength || this.IgnoreMetadata) - { - this.InputProcessor.Skip(remaining); - return; - } - - byte[] identifier = new byte[Icclength]; - this.InputProcessor.ReadFull(identifier, 0, Icclength); - remaining -= Icclength; // We have read it by this point - - if (ProfileResolver.IsProfile(identifier, ProfileResolver.IccMarker)) - { - byte[] profile = new byte[remaining]; - this.InputProcessor.ReadFull(profile, 0, remaining); - - if (this.MetaData.IccProfile == null) - { - this.MetaData.IccProfile = new IccProfile(profile); - } - else - { - this.MetaData.IccProfile.Extend(profile); - } - } - else - { - // Not an ICC profile we can handle. Skip the remaining bytes so we can carry on and ignore this. - this.InputProcessor.Skip(remaining); - } - } - - /// - /// Processes the application header containing the Adobe identifier - /// which stores image encoding information for DCT filters. - /// - /// The remaining bytes in the segment block. - private void ProcessApp14Marker(int remaining) - { - const int MarkerLength = AdobeMarker.Length; - if (remaining < MarkerLength) - { - // Skip the application header length - this.InputProcessor.Skip(remaining); - return; - } - - this.InputProcessor.ReadFull(this.Temp, 0, MarkerLength); - remaining -= MarkerLength; - - this.isAdobe = AdobeMarker.TryParse(this.Temp, out this.adobe); - - if (remaining > 0) - { - this.InputProcessor.Skip(remaining); - } - } - - /// - /// Processes the Define Quantization Marker and tables. Specified in section B.2.4.1. - /// - /// The remaining bytes in the segment block. - /// - /// Thrown if the tables do not match the header - /// - private void ProcessDefineQuantizationTablesMarker(int remaining) - { - while (remaining > 0) - { - bool done = false; - - remaining--; - byte x = this.InputProcessor.ReadByte(); - int tq = x & 0x0F; - if (tq > MaxTq) - { - throw new ImageFormatException("Bad Tq value"); - } - - switch (x >> 4) - { - case 0: - if (remaining < Block8x8F.Size) - { - done = true; - break; - } - - remaining -= Block8x8F.Size; - this.InputProcessor.ReadFull(this.Temp, 0, Block8x8F.Size); - - for (int i = 0; i < Block8x8F.Size; i++) - { - this.QuantizationTables[tq][i] = this.Temp[i]; - } - - break; - case 1: - if (remaining < 2 * Block8x8F.Size) - { - done = true; - break; - } - - remaining -= 2 * Block8x8F.Size; - this.InputProcessor.ReadFull(this.Temp, 0, 2 * Block8x8F.Size); - - for (int i = 0; i < Block8x8F.Size; i++) - { - this.QuantizationTables[tq][i] = (this.Temp[2 * i] << 8) | this.Temp[(2 * i) + 1]; - } - - break; - default: - throw new ImageFormatException("Bad Pq value"); - } - - if (done) - { - break; - } - } - - if (remaining != 0) - { - throw new ImageFormatException("DQT has wrong length"); - } - } - - /// - /// Processes the Start of Frame marker. Specified in section B.2.2. - /// - /// The remaining bytes in the segment block. - /// Whether to decode metadata only. - private void ProcessStartOfFrameMarker(int remaining, bool metadataOnly) - { - if (this.ComponentCount != 0) - { - throw new ImageFormatException("Multiple SOF markers"); - } - - switch (remaining) - { - case 6 + (3 * 1): // grayscale image. - this.ComponentCount = 1; - break; - case 6 + (3 * 3): // YCbCr or RGB image. - this.ComponentCount = 3; - break; - case 6 + (3 * 4): // YCbCrK or CMYK image. - this.ComponentCount = 4; - break; - default: - throw new ImageFormatException("Incorrect number of components"); - } - - this.InputProcessor.ReadFull(this.Temp, 0, remaining); - - // We only support 8-bit precision. - if (this.Temp[0] != SupportedPrecision) - { - throw new ImageFormatException("Only 8-Bit precision supported."); - } - - int height = (this.Temp[1] << 8) + this.Temp[2]; - int width = (this.Temp[3] << 8) + this.Temp[4]; - - this.ImageSizeInPixels = new Size(width, height); - - if (this.Temp[5] != this.ComponentCount) - { - throw new ImageFormatException("SOF has wrong length"); - } - - if (!metadataOnly) - { - this.Components = new GolangComponent[this.ComponentCount]; - - for (int i = 0; i < this.ComponentCount; i++) - { - byte componentIdentifier = this.Temp[6 + (3 * i)]; - var component = new GolangComponent(componentIdentifier, i); - component.InitializeCoreData(this); - this.Components[i] = component; - } - - int h0 = this.Components[0].HorizontalSamplingFactor; - int v0 = this.Components[0].VerticalSamplingFactor; - - this.ImageSizeInMCU = this.ImageSizeInPixels.DivideRoundUp(8 * h0, 8 * v0); - - this.ColorSpace = this.DeduceJpegColorSpace(); - - foreach (GolangComponent component in this.Components) - { - component.InitializeDerivedData(this.configuration.MemoryAllocator, this); - } - } - } - - /// - /// Processes a Define Huffman Table marker, and initializes a huffman - /// struct from its contents. Specified in section B.2.4.2. - /// - /// The remaining bytes in the segment block. - private void ProcessDefineHuffmanTablesMarker(int remaining) - { - while (remaining > 0) - { - if (remaining < 17) - { - throw new ImageFormatException($"DHT has wrong length. {remaining}"); - } - - this.InputProcessor.ReadFull(this.Temp, 0, 17); - - int tc = this.Temp[0] >> 4; - if (tc > GolangHuffmanTree.MaxTc) - { - throw new ImageFormatException("Bad Tc value"); - } - - int th = this.Temp[0] & 0x0f; - if (th > GolangHuffmanTree.MaxTh) - { - throw new ImageFormatException("Bad Th value"); - } - - int huffTreeIndex = (tc * GolangHuffmanTree.ThRowSize) + th; - this.HuffmanTrees[huffTreeIndex].ProcessDefineHuffmanTablesMarkerLoop( - ref this.InputProcessor, - this.Temp, - ref remaining); - } - } - - /// - /// Processes the DRI (Define Restart Interval Marker) Which specifies the interval between RSTn markers, in - /// macroblocks - /// - /// The remaining bytes in the segment block. - private void ProcessDefineRestartIntervalMarker(int remaining) - { - if (remaining != 2) - { - throw new ImageFormatException("DRI has wrong length"); - } - - this.InputProcessor.ReadFull(this.Temp, 0, remaining); - this.RestartInterval = (this.Temp[0] << 8) + this.Temp[1]; - } - - /// - /// Processes the SOS (Start of scan marker). - /// - /// The remaining bytes in the segment block. - /// - /// Missing SOF Marker - /// SOS has wrong length - /// - private void ProcessStartOfScanMarker(int remaining) - { - GolangJpegScanDecoder scan = default; - GolangJpegScanDecoder.InitStreamReading(&scan, this, remaining); - this.InputProcessor.Bits = default; - scan.DecodeBlocks(this); - } - - private JpegColorSpace DeduceJpegColorSpace() - { - switch (this.ComponentCount) - { - case 1: - return JpegColorSpace.Grayscale; - case 3: - if (!this.isAdobe || this.adobe.ColorTransform == JpegConstants.Adobe.ColorTransformYCbCr) - { - return JpegColorSpace.YCbCr; - } - - if (this.adobe.ColorTransform == JpegConstants.Adobe.ColorTransformUnknown) - { - return JpegColorSpace.RGB; - } - - break; - case 4: - if (this.adobe.ColorTransform == JpegConstants.Adobe.ColorTransformYcck) - { - return JpegColorSpace.Ycck; - } - - return JpegColorSpace.Cmyk; - } - - throw new ImageFormatException($"Unsupported color mode. Max components 4; found {this.ComponentCount}." - + "JpegDecoder only supports YCbCr, RGB, YccK, CMYK and grayscale color spaces."); - } - - private Image PostProcessIntoImage() - where TPixel : struct, IPixel - { - using (var postProcessor = new JpegImagePostProcessor(this.configuration.MemoryAllocator, this)) - { - var image = new Image(this.configuration, this.ImageWidth, this.ImageHeight, this.MetaData); - postProcessor.PostProcess(image.Frames.RootFrame); - return image; - } - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs index eafbb391c9..57b70dd26e 100644 --- a/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs +++ b/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs @@ -2,8 +2,6 @@ // Licensed under the Apache License, Version 2.0. using System.IO; - -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; using SixLabors.ImageSharp.PixelFormats; namespace SixLabors.ImageSharp.Formats.Jpeg @@ -24,7 +22,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg { Guard.NotNull(stream, nameof(stream)); - using (var decoder = new PdfJsJpegDecoderCore(configuration, this)) + using (var decoder = new JpegDecoderCore(configuration, this)) { return decoder.Decode(stream); } @@ -35,7 +33,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg { Guard.NotNull(stream, nameof(stream)); - using (var decoder = new PdfJsJpegDecoderCore(configuration, this)) + using (var decoder = new JpegDecoderCore(configuration, this)) { return decoder.Identify(stream); } diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/PdfJsJpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs similarity index 85% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/PdfJsJpegDecoderCore.cs rename to src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs index 409908eac0..1eb4dad898 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/PdfJsJpegDecoderCore.cs +++ b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs @@ -5,12 +5,14 @@ using System; using System.Buffers.Binary; using System.Collections.Generic; using System.IO; +using System.Linq; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using SixLabors.ImageSharp.Common.Helpers; using SixLabors.ImageSharp.Formats.Jpeg.Components; using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components; +using SixLabors.ImageSharp.IO; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.MetaData.Profiles.Exif; using SixLabors.ImageSharp.MetaData.Profiles.Icc; @@ -19,14 +21,14 @@ using SixLabors.ImageSharp.Primitives; using SixLabors.Memory; using SixLabors.Primitives; -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort +namespace SixLabors.ImageSharp.Formats.Jpeg { /// /// Performs the jpeg decoding operation. /// Originally ported from /// with additional fixes for both performance and common encoding errors. /// - internal sealed class PdfJsJpegDecoderCore : IRawJpegData + internal sealed class JpegDecoderCore : IRawJpegData { /// /// The only supported precision @@ -51,12 +53,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// The DC HUffman tables /// - private PdfJsHuffmanTables dcHuffmanTables; + private HuffmanTables dcHuffmanTables; /// /// The AC HUffman tables /// - private PdfJsHuffmanTables acHuffmanTables; + private HuffmanTables acHuffmanTables; /// /// The fast AC tables used for entropy decoding @@ -69,10 +71,25 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort private ushort resetInterval; /// - /// Whether the image has a EXIF header + /// Whether the image has an EXIF marker /// private bool isExif; + /// + /// Contains exif data + /// + private byte[] exifData; + + /// + /// Whether the image has an ICC marker + /// + private bool isIcc; + + /// + /// Contains ICC data + /// + private byte[] iccData; + /// /// Contains information about the JFIF marker /// @@ -84,11 +101,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort private AdobeMarker adobe; /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// The configuration. /// The options. - public PdfJsJpegDecoderCore(Configuration configuration, IJpegDecoderOptions options) + public JpegDecoderCore(Configuration configuration, IJpegDecoderOptions options) { this.configuration = configuration ?? Configuration.Default; this.IgnoreMetadata = options.IgnoreMetadata; @@ -97,7 +114,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// Gets the frame /// - public PdfJsFrame Frame { get; private set; } + public JpegFrame Frame { get; private set; } /// public Size ImageSizeInPixels { get; private set; } @@ -146,7 +163,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// Gets the components. /// - public PdfJsFrameComponent[] Components => this.Frame.Components; + public JpegComponent[] Components => this.Frame.Components; /// IEnumerable IRawJpegData.Components => this.Components; @@ -159,14 +176,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// The buffer to read file markers to /// The input stream - /// The - public static PdfJsFileMarker FindNextFileMarker(byte[] marker, DoubleBufferedStreamReader stream) + /// The + public static JpegFileMarker FindNextFileMarker(byte[] marker, DoubleBufferedStreamReader stream) { int value = stream.Read(marker, 0, 2); if (value == 0) { - return new PdfJsFileMarker(JpegConstants.Markers.EOI, stream.Length - 2); + return new JpegFileMarker(JpegConstants.Markers.EOI, stream.Length - 2); } if (marker[0] == JpegConstants.Markers.XFF) @@ -179,16 +196,16 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort int suffix = stream.ReadByte(); if (suffix == -1) { - return new PdfJsFileMarker(JpegConstants.Markers.EOI, stream.Length - 2); + return new JpegFileMarker(JpegConstants.Markers.EOI, stream.Length - 2); } m = suffix; } - return new PdfJsFileMarker((byte)m, stream.Position - 2); + return new JpegFileMarker((byte)m, stream.Position - 2); } - return new PdfJsFileMarker(marker[1], stream.Position - 2, true); + return new JpegFileMarker(marker[1], stream.Position - 2, true); } /// @@ -201,6 +218,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort where TPixel : struct, IPixel { this.ParseStream(stream); + this.InitExifProfile(); + this.InitIccProfile(); this.InitDerivedMetaDataProperties(); return this.PostProcessIntoImage(); } @@ -212,6 +231,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort public IImageInfo Identify(Stream stream) { this.ParseStream(stream, true); + this.InitExifProfile(); + this.InitIccProfile(); this.InitDerivedMetaDataProperties(); return new ImageInfo(new PixelTypeInfo(this.BitsPerPixel), this.ImageWidth, this.ImageHeight, this.MetaData); } @@ -228,7 +249,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort // Check for the Start Of Image marker. this.InputStream.Read(this.markerBuffer, 0, 2); - var fileMarker = new PdfJsFileMarker(this.markerBuffer[1], 0); + var fileMarker = new JpegFileMarker(this.markerBuffer[1], 0); if (fileMarker.Marker != JpegConstants.Markers.SOI) { throw new ImageFormatException("Missing SOI marker."); @@ -236,14 +257,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort this.InputStream.Read(this.markerBuffer, 0, 2); byte marker = this.markerBuffer[1]; - fileMarker = new PdfJsFileMarker(marker, (int)this.InputStream.Position - 2); + fileMarker = new JpegFileMarker(marker, (int)this.InputStream.Position - 2); // Only assign what we need if (!metadataOnly) { this.QuantizationTables = new Block8x8F[4]; - this.dcHuffmanTables = new PdfJsHuffmanTables(); - this.acHuffmanTables = new PdfJsHuffmanTables(); + this.dcHuffmanTables = new HuffmanTables(); + this.acHuffmanTables = new HuffmanTables(); this.fastACTables = new FastACTables(this.configuration.MemoryAllocator); } @@ -403,6 +424,32 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort throw new ImageFormatException($"Unsupported color mode. Max components 4; found {this.ComponentCount}"); } + /// + /// Initializes the EXIF profile. + /// + private void InitExifProfile() + { + if (this.isExif) + { + this.MetaData.ExifProfile = new ExifProfile(this.exifData); + } + } + + /// + /// Initializes the ICC profile. + /// + private void InitIccProfile() + { + if (this.isIcc) + { + var profile = new IccProfile(this.iccData); + if (profile.CheckIsValid()) + { + this.MetaData.IccProfile = profile; + } + } + } + /// /// Assigns derived metadata properties to , eg. horizontal and vertical resolution if it has a JFIF header. /// @@ -431,11 +478,19 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort this.MetaData.ResolutionUnits = UnitConverter.ExifProfileToResolutionUnit(this.MetaData.ExifProfile); } } + } - if (this.MetaData.IccProfile?.CheckIsValid() == false) - { - this.MetaData.IccProfile = null; - } + /// + /// Extends the profile with additional data. + /// + /// The profile data array. + /// The array containing addition profile data. + private void ExtendProfile(ref byte[] profile, byte[] extension) + { + int currentLength = profile.Length; + + Array.Resize(ref profile, currentLength + extension.Length); + Buffer.BlockCopy(extension, 0, profile, currentLength, extension.Length); } /// @@ -469,7 +524,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// The remaining bytes in the segment block. private void ProcessApp1Marker(int remaining) { - if (remaining < 6 || this.IgnoreMetadata) + const int Exif00 = 6; + if (remaining < Exif00 || this.IgnoreMetadata) { // Skip the application header length this.InputStream.Skip(remaining); @@ -482,7 +538,16 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort if (ProfileResolver.IsProfile(profile, ProfileResolver.ExifMarker)) { this.isExif = true; - this.MetaData.ExifProfile = new ExifProfile(profile); + if (this.exifData == null) + { + // The first 6 bytes (Exif00) will be skipped, because this is Jpeg specific + this.exifData = profile.Skip(Exif00).ToArray(); + } + else + { + // If the EXIF information exceeds 64K, it will be split over multiple APP1 markers + this.ExtendProfile(ref this.exifData, profile.Skip(Exif00).ToArray()); + } } } @@ -506,16 +571,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort if (ProfileResolver.IsProfile(identifier, ProfileResolver.IccMarker)) { + this.isIcc = true; byte[] profile = new byte[remaining]; this.InputStream.Read(profile, 0, remaining); - if (this.MetaData.IccProfile == null) + if (this.iccData == null) { - this.MetaData.IccProfile = new IccProfile(profile); + this.iccData = profile; } else { - this.MetaData.IccProfile.Extend(profile); + // If the ICC information exceeds 64K, it will be split over multiple APP2 markers + this.ExtendProfile(ref this.iccData, profile); } } else @@ -630,7 +697,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// The remaining bytes in the segment block. /// The current frame marker. /// Whether to parse metadata only - private void ProcessStartOfFrameMarker(int remaining, PdfJsFileMarker frameMarker, bool metadataOnly) + private void ProcessStartOfFrameMarker(int remaining, in JpegFileMarker frameMarker, bool metadataOnly) { if (this.Frame != null) { @@ -645,7 +712,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort throw new ImageFormatException("Only 8-Bit precision supported."); } - this.Frame = new PdfJsFrame + this.Frame = new JpegFrame { Extended = frameMarker.Marker == JpegConstants.Markers.SOF1, Progressive = frameMarker.Marker == JpegConstants.Markers.SOF2, @@ -667,7 +734,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort { // No need to pool this. They max out at 4 this.Frame.ComponentIds = new byte[this.Frame.ComponentCount]; - this.Frame.Components = new PdfJsFrameComponent[this.Frame.ComponentCount]; + this.Frame.Components = new JpegComponent[this.Frame.ComponentCount]; this.ColorSpace = this.DeduceJpegColorSpace(); for (int i = 0; i < this.Frame.ComponentCount; i++) @@ -686,7 +753,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort maxV = v; } - var component = new PdfJsFrameComponent(this.configuration.MemoryAllocator, this.Frame, this.temp[index], h, v, this.temp[index + 2], i); + var component = new JpegComponent(this.configuration.MemoryAllocator, this.Frame, this.temp[index], h, v, this.temp[index + 2], i); this.Frame.Components[i] = component; this.Frame.ComponentIds[i] = component.Id; @@ -709,7 +776,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// The remaining bytes in the segment block. private void ProcessDefineHuffmanTablesMarker(int remaining) { - using (IManagedByteBuffer huffmanData = this.configuration.MemoryAllocator.AllocateCleanManagedByteBuffer(256)) + using (IManagedByteBuffer huffmanData = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(256, AllocationOptions.Clean)) { ref byte huffmanDataRef = ref MemoryMarshal.GetReference(huffmanData.GetSpan()); for (int i = 2; i < remaining;) @@ -717,7 +784,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort byte huffmanTableSpec = (byte)this.InputStream.ReadByte(); this.InputStream.Read(huffmanData.Array, 0, 16); - using (IManagedByteBuffer codeLengths = this.configuration.MemoryAllocator.AllocateCleanManagedByteBuffer(17)) + using (IManagedByteBuffer codeLengths = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(17, AllocationOptions.Clean)) { ref byte codeLengthsRef = ref MemoryMarshal.GetReference(codeLengths.GetSpan()); int codeLengthSum = 0; @@ -727,7 +794,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort codeLengthSum += Unsafe.Add(ref codeLengthsRef, j) = Unsafe.Add(ref huffmanDataRef, j - 1); } - using (IManagedByteBuffer huffmanValues = this.configuration.MemoryAllocator.AllocateCleanManagedByteBuffer(256)) + using (IManagedByteBuffer huffmanValues = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(256, AllocationOptions.Clean)) { this.InputStream.Read(huffmanValues.Array, 0, codeLengthSum); @@ -794,7 +861,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort throw new ImageFormatException("Unknown component selector"); } - ref PdfJsFrameComponent component = ref this.Frame.Components[componentIndex]; + ref JpegComponent component = ref this.Frame.Components[componentIndex]; int tableSpec = this.InputStream.ReadByte(); component.DCHuffmanTableId = tableSpec >> 4; component.ACHuffmanTableId = tableSpec & 15; @@ -831,9 +898,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// The codelengths /// The values [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void BuildHuffmanTable(PdfJsHuffmanTables tables, int index, ReadOnlySpan codeLengths, ReadOnlySpan values) + private void BuildHuffmanTable(HuffmanTables tables, int index, ReadOnlySpan codeLengths, ReadOnlySpan values) { - tables[index] = new PdfJsHuffmanTable(this.configuration.MemoryAllocator, codeLengths, values); + tables[index] = new HuffmanTable(this.configuration.MemoryAllocator, codeLengths, values); } /// diff --git a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs index ada33f2b84..1a3bb77234 100644 --- a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs +++ b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs @@ -4,9 +4,11 @@ using System; using System.Buffers.Binary; using System.IO; +using System.Linq; using System.Runtime.CompilerServices; using SixLabors.ImageSharp.Common.Helpers; using SixLabors.ImageSharp.Formats.Jpeg.Components; +using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; using SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.MetaData.Profiles.Exif; @@ -214,6 +216,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg // Write the Start Of Image marker. this.WriteApplicationHeader(image.MetaData); + // Write Exif and ICC profiles this.WriteProfiles(image); // Write the quantization tables. @@ -430,7 +433,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg /// The image meta data. private void WriteApplicationHeader(ImageMetaData meta) { - // Write the start of image marker. Markers are always prefixed with with 0xff. + // Write the start of image marker. Markers are always prefixed with 0xff. this.buffer[0] = JpegConstants.Markers.XFF; this.buffer[1] = JpegConstants.Markers.SOI; @@ -620,27 +623,59 @@ namespace SixLabors.ImageSharp.Formats.Jpeg /// private void WriteExifProfile(ExifProfile exifProfile) { - const int Max = 65533; + const int MaxBytesApp1 = 65533; + const int MaxBytesWithExifId = 65527; + byte[] data = exifProfile?.ToByteArray(); + if (data == null || data.Length == 0) { return; } - if (data.Length > Max) + data = ProfileResolver.ExifMarker.Concat(data).ToArray(); + + int remaining = data.Length; + int bytesToWrite = remaining > MaxBytesApp1 ? MaxBytesApp1 : remaining; + int app1Length = bytesToWrite + 2; + + this.WriteApp1Header(app1Length); + + // write the exif data + this.outputStream.Write(data, 0, bytesToWrite); + remaining -= bytesToWrite; + + // if the exif data exceeds 64K, write it in multiple APP1 Markers + for (int idx = MaxBytesApp1; idx < data.Length; idx += MaxBytesWithExifId) { - throw new ImageFormatException($"Exif profile size exceeds limit. nameof{Max}"); - } + bytesToWrite = remaining > MaxBytesWithExifId ? MaxBytesWithExifId : remaining; + app1Length = bytesToWrite + 2 + 6; - int length = data.Length + 2; + this.WriteApp1Header(app1Length); + // write Exif00 marker + ProfileResolver.ExifMarker.AsSpan().CopyTo(this.buffer.AsSpan()); + this.outputStream.Write(this.buffer, 0, 6); + + // write the exif data + this.outputStream.Write(data, idx, bytesToWrite); + + remaining -= bytesToWrite; + } + } + + /// + /// Writes the App1 header. + /// + /// The length of the data the app1 marker contains + private void WriteApp1Header(int app1Length) + { this.buffer[0] = JpegConstants.Markers.XFF; this.buffer[1] = JpegConstants.Markers.APP1; // Application Marker - this.buffer[2] = (byte)((length >> 8) & 0xFF); - this.buffer[3] = (byte)(length & 0xFF); + this.buffer[2] = (byte)((app1Length >> 8) & 0xFF); + this.buffer[3] = (byte)(app1Length & 0xFF); this.outputStream.Write(this.buffer, 0, 4); - this.outputStream.Write(data, 0, data.Length); } /// @@ -652,7 +687,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg /// private void WriteIccProfile(IccProfile iccProfile) { - // Just incase someone set the value to null by accident. if (iccProfile == null) { return; @@ -908,7 +942,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg /// The marker length. private void WriteMarkerHeader(byte marker, int length) { - // Markers are always prefixed with with 0xff. + // Markers are always prefixed with 0xff. this.buffer[0] = JpegConstants.Markers.XFF; this.buffer[1] = marker; this.buffer[2] = (byte)(length >> 8); diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/PdfJsJpegDecoder.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/PdfJsJpegDecoder.cs deleted file mode 100644 index e12278cc7e..0000000000 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/PdfJsJpegDecoder.cs +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.IO; -using SixLabors.ImageSharp.PixelFormats; - -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort -{ - /// - /// Image decoder for generating an image out of a jpg stream. - /// - internal sealed class PdfJsJpegDecoder : IImageDecoder, IJpegDecoderOptions, IImageInfoDetector - { - /// - /// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded. - /// - public bool IgnoreMetadata { get; set; } - - /// - public Image Decode(Configuration configuration, Stream stream) - where TPixel : struct, IPixel - { - Guard.NotNull(stream, nameof(stream)); - - using (var decoder = new PdfJsJpegDecoderCore(configuration, this)) - { - return decoder.Decode(stream); - } - } - - /// - public IImageInfo Identify(Configuration configuration, Stream stream) - { - Guard.NotNull(stream, nameof(stream)); - - using (var decoder = new PdfJsJpegDecoderCore(configuration, this)) - { - return decoder.Identify(stream); - } - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/README.md b/src/ImageSharp/Formats/Jpeg/README.md index 54bc14847c..2f766ca0c3 100644 --- a/src/ImageSharp/Formats/Jpeg/README.md +++ b/src/ImageSharp/Formats/Jpeg/README.md @@ -1,3 +1,8 @@ -Encoder/Decoder adapted and extended from: +Encoder adapted and extended from: +https://golang.org/src/image/jpeg/ -https://golang.org/src/image/jpeg/ \ No newline at end of file +Decoder orchestration code is based on: +https://github.com/mozilla/pdf.js + +Huffmann decoder is based on: +https://github.com/rds1983/StbSharp \ No newline at end of file diff --git a/src/ImageSharp/Formats/Png/PngChunkType.cs b/src/ImageSharp/Formats/Png/PngChunkType.cs index 51adc162b3..e0844ca6b8 100644 --- a/src/ImageSharp/Formats/Png/PngChunkType.cs +++ b/src/ImageSharp/Formats/Png/PngChunkType.cs @@ -4,7 +4,7 @@ namespace SixLabors.ImageSharp.Formats.Png { /// - /// Contains a list of of chunk types. + /// Contains a list of chunk types. /// internal enum PngChunkType : uint { @@ -55,6 +55,11 @@ namespace SixLabors.ImageSharp.Formats.Png /// /// The pHYs chunk specifies the intended pixel size or aspect ratio for display of the image. /// - Physical = 0x70485973U // pHYs + Physical = 0x70485973U, // pHYs + + /// + /// The data chunk which contains the Exif profile. + /// + Exif = 0x65584966U // eXIf } } \ No newline at end of file diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs index 38c550344d..e1ec3c1d66 100644 --- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs +++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs @@ -13,7 +13,9 @@ using SixLabors.ImageSharp.Advanced; using SixLabors.ImageSharp.Common.Helpers; using SixLabors.ImageSharp.Formats.Png.Filters; using SixLabors.ImageSharp.Formats.Png.Zlib; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; +using SixLabors.ImageSharp.MetaData.Profiles.Exif; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -259,6 +261,15 @@ namespace SixLabors.ImageSharp.Formats.Png break; case PngChunkType.Text: this.ReadTextChunk(metadata, chunk.Data.Array, chunk.Length); + break; + case PngChunkType.Exif: + if (!this.ignoreMetadata) + { + byte[] exifData = new byte[chunk.Length]; + Buffer.BlockCopy(chunk.Data.Array, 0, exifData, 0, chunk.Length); + metadata.ExifProfile = new ExifProfile(exifData); + } + break; case PngChunkType.End: this.isEndChunkReached = true; @@ -370,7 +381,7 @@ namespace SixLabors.ImageSharp.Formats.Png return false; } - buffer = this.MemoryAllocator.AllocateCleanManagedByteBuffer(bytesPerScanline * 8 / bits); + buffer = this.MemoryAllocator.AllocateManagedByteBuffer(bytesPerScanline * 8 / bits, AllocationOptions.Clean); byte[] result = buffer.Array; int mask = 0xFF >> (8 - bits); int resultOffset = 0; @@ -437,8 +448,8 @@ namespace SixLabors.ImageSharp.Formats.Png this.bytesPerSample = this.header.BitDepth / 8; } - this.previousScanline = this.MemoryAllocator.AllocateCleanManagedByteBuffer(this.bytesPerScanline); - this.scanline = this.configuration.MemoryAllocator.AllocateCleanManagedByteBuffer(this.bytesPerScanline); + this.previousScanline = this.MemoryAllocator.AllocateManagedByteBuffer(this.bytesPerScanline, AllocationOptions.Clean); + this.scanline = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(this.bytesPerScanline, AllocationOptions.Clean); } /// @@ -1170,7 +1181,7 @@ namespace SixLabors.ImageSharp.Formats.Png /// /// Decodes and assigns marker colors that identify transparent pixels in non indexed images /// - /// The aplha tRNS array + /// The alpha tRNS array private void AssignTransparentMarkers(ReadOnlySpan alpha) { if (this.pngColorType == PngColorType.Rgb) @@ -1217,7 +1228,7 @@ namespace SixLabors.ImageSharp.Formats.Png /// /// The type of pixel we are expanding to /// The defiltered scanline - /// Thecurrent output image row + /// The current output image row private void ProcessScanlineFromPalette(ReadOnlySpan scanline, Span row) where TPixel : struct, IPixel { @@ -1445,7 +1456,7 @@ namespace SixLabors.ImageSharp.Formats.Png private IManagedByteBuffer ReadChunkData(int length) { // We rent the buffer here to return it afterwards in Decode() - IManagedByteBuffer buffer = this.configuration.MemoryAllocator.AllocateCleanManagedByteBuffer(length); + IManagedByteBuffer buffer = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(length, AllocationOptions.Clean); this.currentStream.Read(buffer.Array, 0, length); diff --git a/src/ImageSharp/Formats/Png/PngEncoderCore.cs b/src/ImageSharp/Formats/Png/PngEncoderCore.cs index df0dffa49e..ffe29aecae 100644 --- a/src/ImageSharp/Formats/Png/PngEncoderCore.cs +++ b/src/ImageSharp/Formats/Png/PngEncoderCore.cs @@ -9,6 +9,7 @@ using SixLabors.ImageSharp.Advanced; using SixLabors.ImageSharp.Common.Helpers; using SixLabors.ImageSharp.Formats.Png.Filters; using SixLabors.ImageSharp.Formats.Png.Zlib; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing.Processors.Quantization; @@ -231,6 +232,7 @@ namespace SixLabors.ImageSharp.Formats.Png this.WritePhysicalChunk(stream, image); this.WriteGammaChunk(stream); + this.WriteExifChunk(stream, image); this.WriteDataChunks(image.Frames.RootFrame, quantizedPixelsSpan, stream); this.WriteEndChunk(stream); stream.Flush(); @@ -490,7 +492,7 @@ namespace SixLabors.ImageSharp.Formats.Png /// /// Calculates the correct number of bytes per pixel for the given color type. /// - /// The + /// Bytes per pixel private int CalculateBytesPerPixel() { switch (this.pngColorType) @@ -648,6 +650,22 @@ namespace SixLabors.ImageSharp.Formats.Png this.WriteChunk(stream, PngChunkType.Physical, this.chunkDataBuffer, 0, 9); } + /// + /// Writes the eXIf chunk to the stream, if any EXIF Profile values are present in the meta data. + /// + /// The pixel format. + /// The containing image data. + /// The image. + private void WriteExifChunk(Stream stream, Image image) + where TPixel : struct, IPixel + { + if (image.MetaData.ExifProfile?.Values.Count > 0) + { + image.MetaData.SyncProfiles(); + this.WriteChunk(stream, PngChunkType.Exif, image.MetaData.ExifProfile.ToByteArray()); + } + } + /// /// Writes the gamma information to the stream. /// @@ -678,9 +696,9 @@ namespace SixLabors.ImageSharp.Formats.Png this.bytesPerScanline = this.width * this.bytesPerPixel; int resultLength = this.bytesPerScanline + 1; - this.previousScanline = this.memoryAllocator.AllocateCleanManagedByteBuffer(this.bytesPerScanline); - this.rawScanline = this.memoryAllocator.AllocateCleanManagedByteBuffer(this.bytesPerScanline); - this.result = this.memoryAllocator.AllocateCleanManagedByteBuffer(resultLength); + this.previousScanline = this.memoryAllocator.AllocateManagedByteBuffer(this.bytesPerScanline, AllocationOptions.Clean); + this.rawScanline = this.memoryAllocator.AllocateManagedByteBuffer(this.bytesPerScanline, AllocationOptions.Clean); + this.result = this.memoryAllocator.AllocateManagedByteBuffer(resultLength, AllocationOptions.Clean); switch (this.pngFilterMethod) { @@ -689,29 +707,29 @@ namespace SixLabors.ImageSharp.Formats.Png case PngFilterMethod.Sub: - this.sub = this.memoryAllocator.AllocateCleanManagedByteBuffer(resultLength); + this.sub = this.memoryAllocator.AllocateManagedByteBuffer(resultLength, AllocationOptions.Clean); break; case PngFilterMethod.Up: - this.up = this.memoryAllocator.AllocateCleanManagedByteBuffer(resultLength); + this.up = this.memoryAllocator.AllocateManagedByteBuffer(resultLength, AllocationOptions.Clean); break; case PngFilterMethod.Average: - this.average = this.memoryAllocator.AllocateCleanManagedByteBuffer(resultLength); + this.average = this.memoryAllocator.AllocateManagedByteBuffer(resultLength, AllocationOptions.Clean); break; case PngFilterMethod.Paeth: - this.paeth = this.memoryAllocator.AllocateCleanManagedByteBuffer(resultLength); + this.paeth = this.memoryAllocator.AllocateManagedByteBuffer(resultLength, AllocationOptions.Clean); break; case PngFilterMethod.Adaptive: - this.sub = this.memoryAllocator.AllocateCleanManagedByteBuffer(resultLength); - this.up = this.memoryAllocator.AllocateCleanManagedByteBuffer(resultLength); - this.average = this.memoryAllocator.AllocateCleanManagedByteBuffer(resultLength); - this.paeth = this.memoryAllocator.AllocateCleanManagedByteBuffer(resultLength); + this.sub = this.memoryAllocator.AllocateManagedByteBuffer(resultLength, AllocationOptions.Clean); + this.up = this.memoryAllocator.AllocateManagedByteBuffer(resultLength, AllocationOptions.Clean); + this.average = this.memoryAllocator.AllocateManagedByteBuffer(resultLength, AllocationOptions.Clean); + this.paeth = this.memoryAllocator.AllocateManagedByteBuffer(resultLength, AllocationOptions.Clean); break; } diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/DoubleBufferedStreamReader.cs b/src/ImageSharp/IO/DoubleBufferedStreamReader.cs similarity index 97% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/DoubleBufferedStreamReader.cs rename to src/ImageSharp/IO/DoubleBufferedStreamReader.cs index 7aeee43c2e..94a2f2cbfc 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/DoubleBufferedStreamReader.cs +++ b/src/ImageSharp/IO/DoubleBufferedStreamReader.cs @@ -7,8 +7,7 @@ using System.Runtime.CompilerServices; using SixLabors.Memory; -// TODO: This could be useful elsewhere. -namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components +namespace SixLabors.ImageSharp.IO { /// /// A stream reader that add a secondary level buffer in addition to native stream buffered reading @@ -44,7 +43,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { this.stream = stream; this.length = (int)stream.Length; - this.managedBuffer = memoryAllocator.AllocateCleanManagedByteBuffer(ChunkLength); + this.managedBuffer = memoryAllocator.AllocateManagedByteBuffer(ChunkLength, AllocationOptions.Clean); this.bufferChunk = this.managedBuffer.Array; } diff --git a/src/ImageSharp/Image.Decode.cs b/src/ImageSharp/Image.Decode.cs index 9087db4148..3b014e7bd6 100644 --- a/src/ImageSharp/Image.Decode.cs +++ b/src/ImageSharp/Image.Decode.cs @@ -4,6 +4,7 @@ using System.IO; using System.Linq; using SixLabors.ImageSharp.Formats; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; diff --git a/src/ImageSharp/Image.WrapMemory.cs b/src/ImageSharp/Image.WrapMemory.cs index 3988120e66..e8d9ab7547 100644 --- a/src/ImageSharp/Image.WrapMemory.cs +++ b/src/ImageSharp/Image.WrapMemory.cs @@ -2,6 +2,9 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -13,8 +16,6 @@ namespace SixLabors.ImageSharp /// public static partial class Image { - // TODO: This is a WIP API, should be public when finished. - /// /// Wraps an existing contigous memory area of 'width'x'height' pixels, /// allowing to view/manipulate it as an ImageSharp instance. @@ -26,7 +27,7 @@ namespace SixLabors.ImageSharp /// The height of the memory image /// The /// An instance - internal static Image WrapMemory( + public static Image WrapMemory( Configuration config, Memory pixelMemory, int width, @@ -34,26 +35,117 @@ namespace SixLabors.ImageSharp ImageMetaData metaData) where TPixel : struct, IPixel { - var buffer = new ConsumedBuffer(pixelMemory); - return new Image(config, buffer, width, height, metaData); + var memorySource = new MemorySource(pixelMemory); + return new Image(config, memorySource, width, height, metaData); + } + + /// + /// Wraps an existing contigous memory area of 'width'x'height' pixels, + /// allowing to view/manipulate it as an ImageSharp instance. + /// + /// The pixel type + /// The + /// The pixel memory + /// The width of the memory image + /// The height of the memory image + /// An instance + public static Image WrapMemory( + Configuration config, + Memory pixelMemory, + int width, + int height) + where TPixel : struct, IPixel + { + return WrapMemory(config, pixelMemory, width, height, new ImageMetaData()); } /// /// Wraps an existing contigous memory area of 'width'x'height' pixels, /// allowing to view/manipulate it as an ImageSharp instance. + /// The memory is being observed, the caller remains responsible for managing it's lifecycle. /// /// The pixel type /// The pixel memory /// The width of the memory image /// The height of the memory image /// An instance - internal static Image WrapMemory( + public static Image WrapMemory( Memory pixelMemory, int width, int height) where TPixel : struct, IPixel { - return WrapMemory(Configuration.Default, pixelMemory, width, height, new ImageMetaData()); + return WrapMemory(Configuration.Default, pixelMemory, width, height); + } + + /// + /// Wraps an existing contigous memory area of 'width'x'height' pixels, + /// allowing to view/manipulate it as an ImageSharp instance. + /// The ownership of the is being transfered to the new instance, + /// meaning that the caller is not allowed to dispose . + /// It will be disposed together with the result image. + /// + /// The pixel type + /// The + /// The that is being transfered to the image + /// The width of the memory image + /// The height of the memory image + /// The + /// An instance + public static Image WrapMemory( + Configuration config, + IMemoryOwner pixelMemoryOwner, + int width, + int height, + ImageMetaData metaData) + where TPixel : struct, IPixel + { + var memorySource = new MemorySource(pixelMemoryOwner, false); + return new Image(config, memorySource, width, height, metaData); + } + + /// + /// Wraps an existing contigous memory area of 'width'x'height' pixels, + /// allowing to view/manipulate it as an ImageSharp instance. + /// The ownership of the is being transfered to the new instance, + /// meaning that the caller is not allowed to dispose . + /// It will be disposed together with the result image. + /// + /// The pixel type + /// The + /// The that is being transfered to the image + /// The width of the memory image + /// The height of the memory image + /// An instance + public static Image WrapMemory( + Configuration config, + IMemoryOwner pixelMemoryOwner, + int width, + int height) + where TPixel : struct, IPixel + { + return WrapMemory(config, pixelMemoryOwner, width, height, new ImageMetaData()); + } + + /// + /// Wraps an existing contigous memory area of 'width'x'height' pixels, + /// allowing to view/manipulate it as an ImageSharp instance. + /// The ownership of the is being transfered to the new instance, + /// meaning that the caller is not allowed to dispose . + /// It will be disposed together with the result image. + /// + /// The pixel type + /// The that is being transfered to the image + /// The width of the memory image + /// The height of the memory image + /// An instance + public static Image WrapMemory( + IMemoryOwner pixelMemoryOwner, + int width, + int height) + where TPixel : struct, IPixel + { + return WrapMemory(Configuration.Default, pixelMemoryOwner, width, height); } } } \ No newline at end of file diff --git a/src/ImageSharp/ImageExtensions.Internal.cs b/src/ImageSharp/ImageExtensions.Internal.cs index 6bbc6ec52f..dfdbbd89b8 100644 --- a/src/ImageSharp/ImageExtensions.Internal.cs +++ b/src/ImageSharp/ImageExtensions.Internal.cs @@ -1,6 +1,7 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; diff --git a/src/ImageSharp/ImageFrameCollection.cs b/src/ImageSharp/ImageFrameCollection.cs index 14a16b691e..929dd7e36e 100644 --- a/src/ImageSharp/ImageFrameCollection.cs +++ b/src/ImageSharp/ImageFrameCollection.cs @@ -5,6 +5,7 @@ using System; using System.Collections; using System.Collections.Generic; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -30,14 +31,14 @@ namespace SixLabors.ImageSharp this.frames.Add(new ImageFrame(parent.GetConfiguration(), width, height, backgroundColor)); } - internal ImageFrameCollection(Image parent, int width, int height, IBuffer consumedBuffer) + internal ImageFrameCollection(Image parent, int width, int height, MemorySource memorySource) { Guard.NotNull(parent, nameof(parent)); this.parent = parent; // Frames are already cloned within the caller - this.frames.Add(new ImageFrame(parent.GetConfiguration(), width, height, consumedBuffer)); + this.frames.Add(new ImageFrame(parent.GetConfiguration(), width, height, memorySource)); } internal ImageFrameCollection(Image parent, IEnumerable> frames) diff --git a/src/ImageSharp/ImageFrame{TPixel}.cs b/src/ImageSharp/ImageFrame{TPixel}.cs index 93e888ccaa..a3971fe9ce 100644 --- a/src/ImageSharp/ImageFrame{TPixel}.cs +++ b/src/ImageSharp/ImageFrame{TPixel}.cs @@ -2,10 +2,12 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Numerics; using System.Runtime.CompilerServices; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -86,16 +88,16 @@ namespace SixLabors.ImageSharp this.configuration = configuration; this.MemoryAllocator = configuration.MemoryAllocator; - this.PixelBuffer = this.MemoryAllocator.Allocate2D(width, height, false); + this.PixelBuffer = this.MemoryAllocator.Allocate2D(width, height); this.MetaData = metaData; - this.Clear(configuration.ParallelOptions, backgroundColor); + this.Clear(configuration.GetParallelOptions(), backgroundColor); } /// /// Initializes a new instance of the class wrapping an existing buffer. /// - internal ImageFrame(Configuration configuration, int width, int height, IBuffer consumedBuffer) - : this(configuration, width, height, consumedBuffer, new ImageFrameMetaData()) + internal ImageFrame(Configuration configuration, int width, int height, MemorySource memorySource) + : this(configuration, width, height, memorySource, new ImageFrameMetaData()) { } @@ -106,7 +108,7 @@ namespace SixLabors.ImageSharp Configuration configuration, int width, int height, - IBuffer consumedBuffer, + MemorySource memorySource, ImageFrameMetaData metaData) { Guard.NotNull(configuration, nameof(configuration)); @@ -116,7 +118,7 @@ namespace SixLabors.ImageSharp this.configuration = configuration; this.MemoryAllocator = configuration.MemoryAllocator; - this.PixelBuffer = new Buffer2D(consumedBuffer, width, height); + this.PixelBuffer = new Buffer2D(memorySource, width, height); this.MetaData = metaData; } @@ -272,7 +274,7 @@ namespace SixLabors.ImageSharp this.Height, this.configuration, this.Width, - (int y, IBuffer tempRowBuffer) => + (int y, IMemoryOwner tempRowBuffer) => { Span sourceRow = this.GetPixelRowSpan(y); Span targetRow = target.GetPixelRowSpan(y); diff --git a/src/ImageSharp/ImageSharp.csproj b/src/ImageSharp/ImageSharp.csproj index b40884f4b1..a7ca0a014c 100644 --- a/src/ImageSharp/ImageSharp.csproj +++ b/src/ImageSharp/ImageSharp.csproj @@ -29,27 +29,19 @@ portable True IOperation - 7.3 + Latest - + + All - - - - - - - - - diff --git a/src/ImageSharp/Image{TPixel}.cs b/src/ImageSharp/Image{TPixel}.cs index ad754bc753..8bc5a40bdc 100644 --- a/src/ImageSharp/Image{TPixel}.cs +++ b/src/ImageSharp/Image{TPixel}.cs @@ -8,6 +8,7 @@ using System.Linq; using System.Runtime.CompilerServices; using SixLabors.ImageSharp.Advanced; using SixLabors.ImageSharp.Formats; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -84,23 +85,14 @@ namespace SixLabors.ImageSharp /// /// Initializes a new instance of the class - /// consuming an external buffer instance. + /// wrapping an external /// - internal Image(Configuration configuration, IBuffer consumedBuffer, int width, int height) - : this(configuration, consumedBuffer, width, height, new ImageMetaData()) - { - } - - /// - /// Initializes a new instance of the class - /// consuming an external buffer instance. - /// - internal Image(Configuration configuration, IBuffer consumedBuffer, int width, int height, ImageMetaData metadata) + internal Image(Configuration configuration, MemorySource memorySource, int width, int height, ImageMetaData metadata) { this.configuration = configuration; this.PixelType = new PixelTypeInfo(Unsafe.SizeOf() * 8); this.MetaData = metadata; - this.frames = new ImageFrameCollection(this, width, height, consumedBuffer); + this.frames = new ImageFrameCollection(this, width, height, memorySource); } /// diff --git a/src/ImageSharp/Memory/ArrayPoolMemoryAllocator.Buffer{T}.cs b/src/ImageSharp/Memory/ArrayPoolMemoryAllocator.Buffer{T}.cs deleted file mode 100644 index d0f68c9c63..0000000000 --- a/src/ImageSharp/Memory/ArrayPoolMemoryAllocator.Buffer{T}.cs +++ /dev/null @@ -1,83 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; -using System.Buffers; -using System.Runtime.InteropServices; - -namespace SixLabors.Memory -{ - /// - /// Contains and - /// - public partial class ArrayPoolMemoryAllocator - { - /// - /// The buffer implementation of . - /// In this implementation is owned. - /// - private class Buffer : ManagedBufferBase - where T : struct - { - /// - /// The length of the buffer - /// - private readonly int length; - - /// - /// A weak reference to the source pool. - /// - /// - /// By using a weak reference here, we are making sure that array pools and their retained arrays are always GC-ed - /// after a call to , regardless of having buffer instances still being in use. - /// - private WeakReference> sourcePoolReference; - - public Buffer(byte[] data, int length, ArrayPool sourcePool) - { - this.Data = data; - this.length = length; - this.sourcePoolReference = new WeakReference>(sourcePool); - } - - /// - /// Gets the buffer as a byte array. - /// - protected byte[] Data { get; private set; } - - /// - protected override void Dispose(bool disposing) - { - if (!disposing || this.Data == null || this.sourcePoolReference == null) - { - return; - } - - if (this.sourcePoolReference.TryGetTarget(out ArrayPool pool)) - { - pool.Return(this.Data); - } - - this.sourcePoolReference = null; - this.Data = null; - } - - public override Span GetSpan() => MemoryMarshal.Cast(this.Data.AsSpan()).Slice(0, this.length); - - protected override object GetPinnableObject() => this.Data; - } - - /// - /// The implementation of . - /// - private class ManagedByteBuffer : Buffer, IManagedByteBuffer - { - public ManagedByteBuffer(byte[] data, int length, ArrayPool sourcePool) - : base(data, length, sourcePool) - { - } - - public byte[] Array => this.Data; - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Memory/ArrayPoolMemoryAllocator.CommonFactoryMethods.cs b/src/ImageSharp/Memory/ArrayPoolMemoryAllocator.CommonFactoryMethods.cs deleted file mode 100644 index 78d6e27b21..0000000000 --- a/src/ImageSharp/Memory/ArrayPoolMemoryAllocator.CommonFactoryMethods.cs +++ /dev/null @@ -1,71 +0,0 @@ -using SixLabors.ImageSharp.PixelFormats; - -namespace SixLabors.Memory -{ - /// - /// Contains common factory methods and configuration constants. - /// - public partial class ArrayPoolMemoryAllocator - { - /// - /// The default value for: maximum size of pooled arrays in bytes. - /// Currently set to 24MB, which is equivalent to 8 megapixels of raw data. - /// - internal const int DefaultMaxPooledBufferSizeInBytes = 24 * 1024 * 1024; - - /// - /// The value for: The threshold to pool arrays in which has less buckets for memory safety. - /// - private const int DefaultBufferSelectorThresholdInBytes = 8 * 1024 * 1024; - - /// - /// The default bucket count for . - /// - private const int DefaultLargePoolBucketCount = 6; - - /// - /// The default bucket count for . - /// - private const int DefaultNormalPoolBucketCount = 16; - - /// - /// This is the default. Should be good for most use cases. - /// - /// The memory manager - public static ArrayPoolMemoryAllocator CreateDefault() - { - return new ArrayPoolMemoryAllocator( - DefaultMaxPooledBufferSizeInBytes, - DefaultBufferSelectorThresholdInBytes, - DefaultLargePoolBucketCount, - DefaultNormalPoolBucketCount); - } - - /// - /// For environments with limited memory capabilities. Only small images are pooled, which can result in reduced througput. - /// - /// The memory manager - public static ArrayPoolMemoryAllocator CreateWithModeratePooling() - { - return new ArrayPoolMemoryAllocator(1024 * 1024, 32 * 1024, 16, 24); - } - - /// - /// Only pool small buffers like image rows. - /// - /// The memory manager - public static ArrayPoolMemoryAllocator CreateWithMinimalPooling() - { - return new ArrayPoolMemoryAllocator(64 * 1024, 32 * 1024, 8, 24); - } - - /// - /// RAM is not an issue for me, gimme maximum througput! - /// - /// The memory manager - public static ArrayPoolMemoryAllocator CreateWithAggressivePooling() - { - return new ArrayPoolMemoryAllocator(128 * 1024 * 1024, 32 * 1024 * 1024, 16, 32); - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Memory/ArrayPoolMemoryAllocator.cs b/src/ImageSharp/Memory/ArrayPoolMemoryAllocator.cs deleted file mode 100644 index f1c4c49c34..0000000000 --- a/src/ImageSharp/Memory/ArrayPoolMemoryAllocator.cs +++ /dev/null @@ -1,140 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.Buffers; -using System.Runtime.CompilerServices; - -namespace SixLabors.Memory -{ - /// - /// Implements by allocating memory from . - /// - public sealed partial class ArrayPoolMemoryAllocator : MemoryAllocator - { - /// - /// The for small-to-medium buffers which is not kept clean. - /// - private ArrayPool normalArrayPool; - - /// - /// The for huge buffers, which is not kept clean. - /// - private ArrayPool largeArrayPool; - - private readonly int maxArraysPerBucketNormalPool; - - private readonly int maxArraysPerBucketLargePool; - - /// - /// Initializes a new instance of the class. - /// - public ArrayPoolMemoryAllocator() - : this(DefaultMaxPooledBufferSizeInBytes, DefaultBufferSelectorThresholdInBytes) - { - } - - /// - /// Initializes a new instance of the class. - /// - /// The maximum size of pooled arrays. Arrays over the thershold are gonna be always allocated. - public ArrayPoolMemoryAllocator(int maxPoolSizeInBytes) - : this(maxPoolSizeInBytes, GetLargeBufferThresholdInBytes(maxPoolSizeInBytes)) - { - } - - /// - /// Initializes a new instance of the class. - /// - /// The maximum size of pooled arrays. Arrays over the thershold are gonna be always allocated. - /// Arrays over this threshold will be pooled in which has less buckets for memory safety. - public ArrayPoolMemoryAllocator(int maxPoolSizeInBytes, int poolSelectorThresholdInBytes) - : this(maxPoolSizeInBytes, poolSelectorThresholdInBytes, DefaultLargePoolBucketCount, DefaultNormalPoolBucketCount) - { - } - - /// - /// Initializes a new instance of the class. - /// - /// The maximum size of pooled arrays. Arrays over the thershold are gonna be always allocated. - /// The threshold to pool arrays in which has less buckets for memory safety. - /// Max arrays per bucket for the large array pool - /// Max arrays per bucket for the normal array pool - public ArrayPoolMemoryAllocator(int maxPoolSizeInBytes, int poolSelectorThresholdInBytes, int maxArraysPerBucketLargePool, int maxArraysPerBucketNormalPool) - { - ImageSharp.Guard.MustBeGreaterThan(maxPoolSizeInBytes, 0, nameof(maxPoolSizeInBytes)); - Guard.MustBeLessThanOrEqualTo(poolSelectorThresholdInBytes, maxPoolSizeInBytes, nameof(poolSelectorThresholdInBytes)); - - this.MaxPoolSizeInBytes = maxPoolSizeInBytes; - this.PoolSelectorThresholdInBytes = poolSelectorThresholdInBytes; - this.maxArraysPerBucketLargePool = maxArraysPerBucketLargePool; - this.maxArraysPerBucketNormalPool = maxArraysPerBucketNormalPool; - - this.InitArrayPools(); - } - - /// - /// Gets the maximum size of pooled arrays in bytes. - /// - public int MaxPoolSizeInBytes { get; } - - /// - /// Gets the threshold to pool arrays in which has less buckets for memory safety. - /// - public int PoolSelectorThresholdInBytes { get; } - - /// - public override void ReleaseRetainedResources() - { - this.InitArrayPools(); - } - - /// - internal override IBuffer Allocate(int length, bool clear) - { - int itemSizeBytes = Unsafe.SizeOf(); - int bufferSizeInBytes = length * itemSizeBytes; - - ArrayPool pool = this.GetArrayPool(bufferSizeInBytes); - byte[] byteArray = pool.Rent(bufferSizeInBytes); - - var buffer = new Buffer(byteArray, length, pool); - if (clear) - { - buffer.Clear(); - } - - return buffer; - } - - /// - internal override IManagedByteBuffer AllocateManagedByteBuffer(int length, bool clear) - { - ArrayPool pool = this.GetArrayPool(length); - byte[] byteArray = pool.Rent(length); - - var buffer = new ManagedByteBuffer(byteArray, length, pool); - if (clear) - { - buffer.Clear(); - } - - return buffer; - } - - private static int GetLargeBufferThresholdInBytes(int maxPoolSizeInBytes) - { - return maxPoolSizeInBytes / 4; - } - - private ArrayPool GetArrayPool(int bufferSizeInBytes) - { - return bufferSizeInBytes <= this.PoolSelectorThresholdInBytes ? this.normalArrayPool : this.largeArrayPool; - } - - private void InitArrayPools() - { - this.largeArrayPool = ArrayPool.Create(this.MaxPoolSizeInBytes, this.maxArraysPerBucketLargePool); - this.normalArrayPool = ArrayPool.Create(this.PoolSelectorThresholdInBytes, this.maxArraysPerBucketNormalPool); - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Memory/BasicArrayBuffer.cs b/src/ImageSharp/Memory/BasicArrayBuffer.cs deleted file mode 100644 index 5e3893d089..0000000000 --- a/src/ImageSharp/Memory/BasicArrayBuffer.cs +++ /dev/null @@ -1,59 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; -using System.Runtime.CompilerServices; - -namespace SixLabors.Memory -{ - /// - /// Wraps an array as an instance. In this implementation is owned. - /// - internal class BasicArrayBuffer : ManagedBufferBase - where T : struct - { - public BasicArrayBuffer(T[] array, int length) - { - ImageSharp.DebugGuard.MustBeLessThanOrEqualTo(length, array.Length, nameof(length)); - this.Array = array; - this.Length = length; - } - - public BasicArrayBuffer(T[] array) - : this(array, array.Length) - { - } - - public T[] Array { get; } - - public int Length { get; } - - /// - /// Returns a reference to specified element of the buffer. - /// - /// The index - /// The reference to the specified element - public ref T this[int index] - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get - { - DebugGuard.MustBeLessThan(index, this.Length, nameof(index)); - - Span span = this.GetSpan(); - return ref span[index]; - } - } - - protected override void Dispose(bool disposing) - { - } - - public override Span GetSpan() => this.Array.AsSpan(0, this.Length); - - protected override object GetPinnableObject() - { - return this.Array; - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Memory/BasicByteBuffer.cs b/src/ImageSharp/Memory/BasicByteBuffer.cs deleted file mode 100644 index 9f995e347f..0000000000 --- a/src/ImageSharp/Memory/BasicByteBuffer.cs +++ /dev/null @@ -1,13 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -namespace SixLabors.Memory -{ - internal sealed class BasicByteBuffer : BasicArrayBuffer, IManagedByteBuffer - { - internal BasicByteBuffer(byte[] array) - : base(array) - { - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Memory/Buffer2DExtensions.cs b/src/ImageSharp/Memory/Buffer2DExtensions.cs index c277525703..107457ae73 100644 --- a/src/ImageSharp/Memory/Buffer2DExtensions.cs +++ b/src/ImageSharp/Memory/Buffer2DExtensions.cs @@ -3,9 +3,10 @@ using System; using System.Runtime.CompilerServices; + using SixLabors.Primitives; -namespace SixLabors.Memory +namespace SixLabors.ImageSharp.Memory { /// /// Defines extension methods for . @@ -18,7 +19,7 @@ namespace SixLabors.Memory internal static Span GetSpan(this Buffer2D buffer) where T : struct { - return buffer.Buffer.GetSpan(); + return buffer.MemorySource.GetSpan(); } /// @@ -61,7 +62,7 @@ namespace SixLabors.Memory public static Memory GetRowMemory(this Buffer2D buffer, int y) where T : struct { - return buffer.Buffer.Memory.Slice(y * buffer.Width, buffer.Width); + return buffer.MemorySource.Memory.Slice(y * buffer.Width, buffer.Width); } /// diff --git a/src/ImageSharp/Memory/Buffer2D{T}.cs b/src/ImageSharp/Memory/Buffer2D{T}.cs index b76c06df81..41a560cdb6 100644 --- a/src/ImageSharp/Memory/Buffer2D{T}.cs +++ b/src/ImageSharp/Memory/Buffer2D{T}.cs @@ -3,9 +3,10 @@ using System; using System.Runtime.CompilerServices; + using SixLabors.Primitives; -namespace SixLabors.Memory +namespace SixLabors.ImageSharp.Memory { /// /// Represents a buffer of value type objects @@ -15,15 +16,17 @@ namespace SixLabors.Memory internal sealed class Buffer2D : IDisposable where T : struct { + private MemorySource memorySource; + /// /// Initializes a new instance of the class. /// - /// The buffer to wrap + /// The buffer to wrap /// The number of elements in a row /// The number of rows - public Buffer2D(IBuffer wrappedBuffer, int width, int height) + public Buffer2D(MemorySource memorySource, int width, int height) { - this.Buffer = wrappedBuffer; + this.memorySource = memorySource; this.Width = width; this.Height = height; } @@ -39,13 +42,13 @@ namespace SixLabors.Memory public int Height { get; private set; } /// - /// Gets the backing + /// Gets the backing /// - public IBuffer Buffer { get; private set; } + public MemorySource MemorySource => this.memorySource; - public Memory Memory => this.Buffer.Memory; + public Memory Memory => this.MemorySource.Memory; - public Span Span => this.Buffer.GetSpan(); + public Span Span => this.Memory.Span; /// /// Gets a reference to the element at the specified position. @@ -59,8 +62,8 @@ namespace SixLabors.Memory get { ImageSharp.DebugGuard.MustBeLessThan(x, this.Width, nameof(x)); - DebugGuard.MustBeLessThan(y, this.Height, nameof(y)); - Span span = this.Buffer.GetSpan(); + ImageSharp.DebugGuard.MustBeLessThan(y, this.Height, nameof(y)); + Span span = this.Span; return ref span[(this.Width * y) + x]; } } @@ -70,7 +73,7 @@ namespace SixLabors.Memory /// public void Dispose() { - this.Buffer?.Dispose(); + this.MemorySource.Dispose(); } /// @@ -79,36 +82,15 @@ namespace SixLabors.Memory /// public static void SwapOrCopyContent(Buffer2D destination, Buffer2D source) { - if (source.Buffer.IsMemoryOwner && destination.Buffer.IsMemoryOwner) - { - SwapContents(destination, source); - } - else - { - if (destination.Size() != source.Size()) - { - throw new InvalidOperationException("SwapOrCopyContents(): buffers should both owned or the same size!"); - } - - source.Span.CopyTo(destination.Span); - } + MemorySource.SwapOrCopyContent(ref destination.memorySource, ref source.memorySource); + SwapDimensionData(destination, source); } - /// - /// Swap the contents (, , ) of the two buffers. - /// Useful to transfer the contents of a temporary to a persistent - /// - /// The first buffer - /// The second buffer - private static void SwapContents(Buffer2D a, Buffer2D b) + private static void SwapDimensionData(Buffer2D a, Buffer2D b) { Size aSize = a.Size(); Size bSize = b.Size(); - IBuffer temp = a.Buffer; - a.Buffer = b.Buffer; - b.Buffer = temp; - b.Width = aSize.Width; b.Height = aSize.Height; diff --git a/src/ImageSharp/Memory/BufferArea{T}.cs b/src/ImageSharp/Memory/BufferArea{T}.cs index 6a2146fd20..f71a281390 100644 --- a/src/ImageSharp/Memory/BufferArea{T}.cs +++ b/src/ImageSharp/Memory/BufferArea{T}.cs @@ -1,8 +1,11 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. using System; using System.Runtime.CompilerServices; + using SixLabors.Primitives; -namespace SixLabors.Memory +namespace SixLabors.ImageSharp.Memory { /// /// Represents a rectangular area inside a 2D memory buffer (). @@ -120,7 +123,7 @@ namespace SixLabors.Memory public BufferArea GetSubArea(Rectangle rectangle) { ImageSharp.DebugGuard.MustBeLessThanOrEqualTo(rectangle.Width, this.Rectangle.Width, nameof(rectangle)); - DebugGuard.MustBeLessThanOrEqualTo(rectangle.Height, this.Rectangle.Height, nameof(rectangle)); + ImageSharp.DebugGuard.MustBeLessThanOrEqualTo(rectangle.Height, this.Rectangle.Height, nameof(rectangle)); int x = this.Rectangle.X + rectangle.X; int y = this.Rectangle.Y + rectangle.Y; diff --git a/src/ImageSharp/Memory/ConsumedBuffer.cs b/src/ImageSharp/Memory/ConsumedBuffer.cs deleted file mode 100644 index 73468a3810..0000000000 --- a/src/ImageSharp/Memory/ConsumedBuffer.cs +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; - -namespace SixLabors.Memory -{ - /// - /// A buffer implementation that consumes an existing instance. - /// The ownership of the memory remains external. - /// - /// The value type - internal sealed class ConsumedBuffer : IBuffer - where T : struct - { - public ConsumedBuffer(Memory memory) - { - this.Memory = memory; - } - - public Memory Memory { get; } - - public bool IsMemoryOwner => false; - - public Span GetSpan() - { - return this.Memory.Span; - } - - public void Dispose() - { - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Memory/IBuffer{T}.cs b/src/ImageSharp/Memory/IBuffer{T}.cs deleted file mode 100644 index 847f2741da..0000000000 --- a/src/ImageSharp/Memory/IBuffer{T}.cs +++ /dev/null @@ -1,38 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; -using System.Buffers; - -namespace SixLabors.Memory -{ - /// - /// Represents a contigous memory buffer of value-type items. - /// Depending on it's implementation, an can (1) OWN or (2) CONSUME the instance it wraps. - /// For a deeper understanding of the owner/consumer model, read the following docs:
- /// https://gist.github.com/GrabYourPitchforks/4c3e1935fd4d9fa2831dbfcab35dffc6 - /// TODO: We need more SOC here! For owned buffers we should use . - /// For the consumption case we should not use buffers at all. We need to refactor Buffer2D{T} for this. - /// - /// The value type - internal interface IBuffer : IDisposable - where T : struct - { - /// - /// Gets the ownerd/consumed by this buffer. - /// - Memory Memory { get; } - - /// - /// Gets a value indicating whether this instance is owning the . - /// - bool IsMemoryOwner { get; } - - /// - /// Gets the span to the memory "promised" by this buffer when it's OWNED (1). - /// Gets `this.Memory.Span` when the buffer CONSUMED (2). - /// - /// The - Span GetSpan(); - } -} \ No newline at end of file diff --git a/src/ImageSharp/Memory/IManagedByteBuffer.cs b/src/ImageSharp/Memory/IManagedByteBuffer.cs deleted file mode 100644 index a977eb68fe..0000000000 --- a/src/ImageSharp/Memory/IManagedByteBuffer.cs +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -namespace SixLabors.Memory -{ - /// - /// Represents a byte buffer backed by a managed array. Useful for interop with classic .NET API-s. - /// - internal interface IManagedByteBuffer : IBuffer - { - /// - /// Gets the managed array backing this buffer instance. - /// - byte[] Array { get; } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Memory/ManagedBufferBase.cs b/src/ImageSharp/Memory/ManagedBufferBase.cs deleted file mode 100644 index 8de2f53922..0000000000 --- a/src/ImageSharp/Memory/ManagedBufferBase.cs +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System.Buffers; -using System.Runtime.InteropServices; - -namespace SixLabors.Memory -{ - /// - /// Provides a base class for implementations by implementing pinning logic for adaption. - /// - internal abstract class ManagedBufferBase : MemoryManager, IBuffer - where T : struct - { - private GCHandle pinHandle; - - public bool IsMemoryOwner => true; - - /// - /// Gets the object that should be pinned. - /// - protected abstract object GetPinnableObject(); - - public override unsafe MemoryHandle Pin(int elementIndex = 0) - { - if (!this.pinHandle.IsAllocated) - { - this.pinHandle = GCHandle.Alloc(this.GetPinnableObject(), GCHandleType.Pinned); - } - - void* ptr = (void*)this.pinHandle.AddrOfPinnedObject(); - return new MemoryHandle(ptr, this.pinHandle); - } - - public override void Unpin() - { - if (this.pinHandle.IsAllocated) - { - this.pinHandle.Free(); - } - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/Memory/MemoryAllocator.cs b/src/ImageSharp/Memory/MemoryAllocator.cs deleted file mode 100644 index 2195444fd6..0000000000 --- a/src/ImageSharp/Memory/MemoryAllocator.cs +++ /dev/null @@ -1,38 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -namespace SixLabors.Memory -{ - /// - /// Memory managers are used to allocate memory for image processing operations. - /// - public abstract class MemoryAllocator - { - /// - /// Allocates an of size , optionally - /// clearing the buffer before it gets returned. - /// - /// Type of the data stored in the buffer - /// Size of the buffer to allocate - /// True to clear the backing memory of the buffer - /// A buffer of values of type . - internal abstract IBuffer Allocate(int length, bool clear) - where T : struct; - - /// - /// Allocates an - /// - /// The requested buffer length - /// A value indicating whether to clean the buffer - /// The - internal abstract IManagedByteBuffer AllocateManagedByteBuffer(int length, bool clear); - - /// - /// Releases all retained resources not being in use. - /// Eg: by resetting array pools and letting GC to free the arrays. - /// - public virtual void ReleaseRetainedResources() - { - } - } -} diff --git a/src/ImageSharp/Memory/MemoryAllocatorExtensions.cs b/src/ImageSharp/Memory/MemoryAllocatorExtensions.cs index ab4fc93b7d..b596351b5f 100644 --- a/src/ImageSharp/Memory/MemoryAllocatorExtensions.cs +++ b/src/ImageSharp/Memory/MemoryAllocatorExtensions.cs @@ -1,62 +1,37 @@ -using SixLabors.Primitives; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. -namespace SixLabors.Memory +using System.Buffers; + +using SixLabors.Memory; +using SixLabors.Primitives; + +namespace SixLabors.ImageSharp.Memory { /// /// Extension methods for . /// internal static class MemoryAllocatorExtensions { - /// - /// Allocates a of size . - /// Note: Depending on the implementation, the buffer may not cleared before - /// returning, so it may contain data from an earlier use. - /// - /// Type of the data stored in the buffer - /// The - /// Size of the buffer to allocate - /// A buffer of values of type . - public static IBuffer Allocate(this MemoryAllocator memoryAllocator, int length) - where T : struct - { - return memoryAllocator.Allocate(length, false); - } - - public static IBuffer AllocateClean(this MemoryAllocator memoryAllocator, int length) - where T : struct - { - return memoryAllocator.Allocate(length, true); - } - - public static IManagedByteBuffer AllocateManagedByteBuffer(this MemoryAllocator memoryAllocator, int length) - { - return memoryAllocator.AllocateManagedByteBuffer(length, false); - } - - public static IManagedByteBuffer AllocateCleanManagedByteBuffer(this MemoryAllocator memoryAllocator, int length) - { - return memoryAllocator.AllocateManagedByteBuffer(length, true); - } - - public static Buffer2D Allocate2D(this MemoryAllocator memoryAllocator, int width, int height, bool clear) + public static Buffer2D Allocate2D( + this MemoryAllocator memoryAllocator, + int width, + int height, + AllocationOptions options = AllocationOptions.None) where T : struct { - IBuffer buffer = memoryAllocator.Allocate(width * height, clear); + IMemoryOwner buffer = memoryAllocator.Allocate(width * height, options); + var memorySource = new MemorySource(buffer, true); - return new Buffer2D(buffer, width, height); + return new Buffer2D(memorySource, width, height); } - public static Buffer2D Allocate2D(this MemoryAllocator memoryAllocator, Size size) - where T : struct => - Allocate2D(memoryAllocator, size.Width, size.Height, false); - - public static Buffer2D Allocate2D(this MemoryAllocator memoryAllocator, int width, int height) - where T : struct => - Allocate2D(memoryAllocator, width, height, false); - - public static Buffer2D AllocateClean2D(this MemoryAllocator memoryAllocator, int width, int height) + public static Buffer2D Allocate2D( + this MemoryAllocator memoryAllocator, + Size size, + AllocationOptions options = AllocationOptions.None) where T : struct => - Allocate2D(memoryAllocator, width, height, true); + Allocate2D(memoryAllocator, size.Width, size.Height, options); /// /// Allocates padded buffers for BMP encoder/decoder. (Replacing old PixelRow/PixelArea) diff --git a/src/ImageSharp/Memory/BufferExtensions.cs b/src/ImageSharp/Memory/MemoryOwnerExtensions.cs similarity index 63% rename from src/ImageSharp/Memory/BufferExtensions.cs rename to src/ImageSharp/Memory/MemoryOwnerExtensions.cs index 8ebf866bc5..9b68f52c4d 100644 --- a/src/ImageSharp/Memory/BufferExtensions.cs +++ b/src/ImageSharp/Memory/MemoryOwnerExtensions.cs @@ -2,17 +2,24 @@ // Licensed under the Apache License, Version 2.0. using System; -using System.IO; +using System.Buffers; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -namespace SixLabors.Memory +namespace SixLabors.ImageSharp.Memory { - internal static class BufferExtensions + /// + /// Extension methods for + /// + internal static class MemoryOwnerExtensions { [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static int Length(this IBuffer buffer) - where T : struct => buffer.GetSpan().Length; + public static Span GetSpan(this IMemoryOwner buffer) + => buffer.Memory.Span; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int Length(this IMemoryOwner buffer) + => buffer.GetSpan().Length; /// /// Gets a to an offseted position inside the buffer. @@ -21,8 +28,7 @@ namespace SixLabors.Memory /// The start /// The [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static Span Slice(this IBuffer buffer, int start) - where T : struct + public static Span Slice(this IMemoryOwner buffer, int start) { return buffer.GetSpan().Slice(start); } @@ -35,8 +41,7 @@ namespace SixLabors.Memory /// The length of the slice /// The [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static Span Slice(this IBuffer buffer, int start, int length) - where T : struct + public static Span Slice(this IMemoryOwner buffer, int start, int length) { return buffer.GetSpan().Slice(start, length); } @@ -46,24 +51,13 @@ namespace SixLabors.Memory /// /// The buffer [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static void Clear(this IBuffer buffer) - where T : struct + public static void Clear(this IMemoryOwner buffer) { buffer.GetSpan().Clear(); } - public static ref T GetReference(this IBuffer buffer) + public static ref T GetReference(this IMemoryOwner buffer) where T : struct => ref MemoryMarshal.GetReference(buffer.GetSpan()); - - public static void Read(this Stream stream, IManagedByteBuffer buffer) - { - stream.Read(buffer.Array, 0, buffer.Length()); - } - - public static void Write(this Stream stream, IManagedByteBuffer buffer) - { - stream.Write(buffer.Array, 0, buffer.Length()); - } } } \ No newline at end of file diff --git a/src/ImageSharp/Memory/MemorySource.cs b/src/ImageSharp/Memory/MemorySource.cs new file mode 100644 index 0000000000..f0b0ab0281 --- /dev/null +++ b/src/ImageSharp/Memory/MemorySource.cs @@ -0,0 +1,103 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System; +using System.Buffers; + +using SixLabors.Memory; + +namespace SixLabors.ImageSharp.Memory +{ + /// + /// Holds a that is either OWNED or CONSUMED. + /// When the memory is being owned, the instance is also known. + /// Implements content transfer logic in that depends on the ownership status. + /// This is needed to transfer the contents of a temporary + /// to a persistent without copying the buffer. + /// + /// + /// For a deeper understanding of the owner/consumer model, check out the following docs:
+ /// https://gist.github.com/GrabYourPitchforks/4c3e1935fd4d9fa2831dbfcab35dffc6 + /// https://www.codemag.com/Article/1807051/Introducing-.NET-Core-2.1-Flagship-Types-Span-T-and-Memory-T + /// + internal struct MemorySource : IDisposable + { + /// + /// Initializes a new instance of the struct + /// by wrapping an existing . + /// + /// The to wrap + /// + /// A value indicating whether is an internal memory source managed by ImageSharp. + /// Eg. allocated by a . + /// + public MemorySource(IMemoryOwner memoryOwner, bool isInternalMemorySource) + { + this.MemoryOwner = memoryOwner; + this.Memory = memoryOwner.Memory; + this.HasSwappableContents = isInternalMemorySource; + } + + public MemorySource(Memory memory) + { + this.Memory = memory; + this.MemoryOwner = null; + this.HasSwappableContents = false; + } + + public IMemoryOwner MemoryOwner { get; private set; } + + public Memory Memory { get; private set; } + + /// + /// Gets a value indicating whether we are allowed to swap the contents of this buffer + /// with an other instance. + /// The value is true only and only if is present, + /// and it's coming from an internal source managed by ImageSharp (). + /// + public bool HasSwappableContents { get; } + + public Span GetSpan() => this.Memory.Span; + + public void Clear() => this.Memory.Span.Clear(); + + /// + /// Swaps the contents of 'destination' with 'source' if the buffers are owned (1), + /// copies the contents of 'source' to 'destination' otherwise (2). Buffers should be of same size in case 2! + /// + public static void SwapOrCopyContent(ref MemorySource destination, ref MemorySource source) + { + if (source.HasSwappableContents && destination.HasSwappableContents) + { + SwapContents(ref destination, ref source); + } + else + { + if (destination.Memory.Length != source.Memory.Length) + { + throw new InvalidOperationException("SwapOrCopyContents(): buffers should both owned or the same size!"); + } + + source.Memory.CopyTo(destination.Memory); + } + } + + /// + public void Dispose() + { + this.MemoryOwner?.Dispose(); + } + + private static void SwapContents(ref MemorySource a, ref MemorySource b) + { + IMemoryOwner tempOwner = a.MemoryOwner; + Memory tempMemory = a.Memory; + + a.MemoryOwner = b.MemoryOwner; + a.Memory = b.Memory; + + b.MemoryOwner = tempOwner; + b.Memory = tempMemory; + } + } +} \ No newline at end of file diff --git a/src/ImageSharp/Memory/SimpleGcMemoryAllocator.cs b/src/ImageSharp/Memory/SimpleGcMemoryAllocator.cs deleted file mode 100644 index df69cec6eb..0000000000 --- a/src/ImageSharp/Memory/SimpleGcMemoryAllocator.cs +++ /dev/null @@ -1,19 +0,0 @@ -namespace SixLabors.Memory -{ - /// - /// Implements by newing up arrays by the GC on every allocation requests. - /// - public sealed class SimpleGcMemoryAllocator : MemoryAllocator - { - /// - internal override IBuffer Allocate(int length, bool clear) - { - return new BasicArrayBuffer(new T[length]); - } - - internal override IManagedByteBuffer AllocateManagedByteBuffer(int length, bool clear) - { - return new BasicByteBuffer(new byte[length]); - } - } -} \ No newline at end of file diff --git a/src/ImageSharp/MetaData/Profiles/Exif/ExifConstants.cs b/src/ImageSharp/MetaData/Profiles/Exif/ExifConstants.cs index cca53ba435..555cadafee 100644 --- a/src/ImageSharp/MetaData/Profiles/Exif/ExifConstants.cs +++ b/src/ImageSharp/MetaData/Profiles/Exif/ExifConstants.cs @@ -5,17 +5,18 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif { internal static class ExifConstants { - public static readonly byte[] Header = { - (byte)'E', - (byte)'x', - (byte)'i', - (byte)'f', - 0x00, - 0x00, + public static readonly byte[] LittleEndianByteOrderMarker = { (byte)'I', (byte)'I', 0x2A, 0x00, }; + + public static readonly byte[] BigEndianByteOrderMarker = { + (byte)'M', + (byte)'M', + 0x00, + 0x2A + }; } } \ No newline at end of file diff --git a/src/ImageSharp/MetaData/Profiles/Exif/ExifProfile.cs b/src/ImageSharp/MetaData/Profiles/Exif/ExifProfile.cs index 0f19083e53..6f5af8ffcd 100644 --- a/src/ImageSharp/MetaData/Profiles/Exif/ExifProfile.cs +++ b/src/ImageSharp/MetaData/Profiles/Exif/ExifProfile.cs @@ -3,7 +3,6 @@ using System; using System.Collections.Generic; -using System.Collections.ObjectModel; using System.IO; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; @@ -18,7 +17,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif /// /// The byte array to read the EXIF profile from. /// - private readonly byte[] data; + private byte[] data; /// /// The collection of EXIF values @@ -86,7 +85,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif if (other.data != null) { this.data = new byte[other.data.Length]; - Buffer.BlockCopy(other.data, 0, this.data, 0, other.data.Length); + other.data.AsSpan().CopyTo(this.data); } } diff --git a/src/ImageSharp/MetaData/Profiles/Exif/ExifReader.cs b/src/ImageSharp/MetaData/Profiles/Exif/ExifReader.cs index 6d473fd4b8..db1d0c6228 100644 --- a/src/ImageSharp/MetaData/Profiles/Exif/ExifReader.cs +++ b/src/ImageSharp/MetaData/Profiles/Exif/ExifReader.cs @@ -25,7 +25,6 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif private Endianness endianness = Endianness.BigEndian; private uint exifOffset; private uint gpsOffset; - private int startIndex; public ExifReader(byte[] exifData) { @@ -77,20 +76,6 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif { var values = new List(); - if (this.ReadString(4) == "Exif") - { - if (this.ReadUInt16() != 0) - { - return values; - } - - this.startIndex = 6; - } - else - { - this.position = 0; - } - if (this.ReadString(2) == "II") { this.endianness = Endianness.LittleEndian; @@ -169,7 +154,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif /// The index. private void AddValues(List values, int index) { - this.position = this.startIndex + index; + this.position = index; int count = this.ReadUInt16(); for (int i = 0; i < count; i++) @@ -353,7 +338,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif { int oldIndex = this.position; - uint newIndex = this.ConvertToUInt32(offsetBuffer) + (uint)this.startIndex; + uint newIndex = this.ConvertToUInt32(offsetBuffer); // Ensure that the new index does not overrun the data if (newIndex > int.MaxValue) @@ -454,7 +439,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif { if (value.Tag == ExifTag.JPEGInterchangeFormat && (value.DataType == ExifDataType.Long)) { - this.ThumbnailOffset = (uint)value.Value + (uint)this.startIndex; + this.ThumbnailOffset = (uint)value.Value; } else if (value.Tag == ExifTag.JPEGInterchangeFormatLength && value.DataType == ExifDataType.Long) { diff --git a/src/ImageSharp/MetaData/Profiles/Exif/ExifWriter.cs b/src/ImageSharp/MetaData/Profiles/Exif/ExifWriter.cs index 8749c07559..dc75697e29 100644 --- a/src/ImageSharp/MetaData/Profiles/Exif/ExifWriter.cs +++ b/src/ImageSharp/MetaData/Profiles/Exif/ExifWriter.cs @@ -14,11 +14,6 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif /// internal sealed class ExifWriter { - /// - /// The start index. - /// - private const int StartIndex = 6; - /// /// Which parts will be written. /// @@ -51,6 +46,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif /// public byte[] GetData() { + uint startIndex = 0; uint length; int exifIndex = -1; int gpsIndex = -1; @@ -86,14 +82,20 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif return null; } - length += 10 + 4 + 2; + // two bytes for the byte Order marker 'II', followed by the number 42 (0x2A) and a 0, making 4 bytes total + length += (uint)ExifConstants.LittleEndianByteOrderMarker.Length; + + length += 4 + 2; byte[] result = new byte[length]; - ExifConstants.Header.AsSpan().CopyTo(result); // 0-9 + int i = 0; + + // the byte order marker for little-endian, followed by the number 42 and a 0 + ExifConstants.LittleEndianByteOrderMarker.AsSpan().CopyTo(result.AsSpan(start: i)); + i += ExifConstants.LittleEndianByteOrderMarker.Length; - int i = 10; - uint ifdOffset = ((uint)i - StartIndex) + 4; + uint ifdOffset = ((uint)i - startIndex) + 4; uint thumbnailOffset = ifdOffset + ifdLength + exifLength + gpsLength; if (exifLength > 0) @@ -109,18 +111,18 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif i = WriteUInt32(ifdOffset, result, i); i = this.WriteHeaders(this.ifdIndexes, result, i); i = WriteUInt32(thumbnailOffset, result, i); - i = this.WriteData(this.ifdIndexes, result, i); + i = this.WriteData(startIndex, this.ifdIndexes, result, i); if (exifLength > 0) { i = this.WriteHeaders(this.exifIndexes, result, i); - i = this.WriteData(this.exifIndexes, result, i); + i = this.WriteData(startIndex, this.exifIndexes, result, i); } if (gpsLength > 0) { i = this.WriteHeaders(this.gpsIndexes, result, i); - i = this.WriteData(this.gpsIndexes, result, i); + i = this.WriteData(startIndex, this.gpsIndexes, result, i); } WriteUInt16((ushort)0, result, i); @@ -257,7 +259,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif return newOffset; } - private int WriteData(List indexes, Span destination, int offset) + private int WriteData(uint startIndex, List indexes, Span destination, int offset) { if (this.dataOffsets.Count == 0) { @@ -272,7 +274,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif ExifValue value = this.values[index]; if (value.Length > 4) { - WriteUInt32((uint)(newOffset - StartIndex), destination, this.dataOffsets[i++]); + WriteUInt32((uint)(newOffset - startIndex), destination, this.dataOffsets[i++]); newOffset = this.WriteValue(value, destination, newOffset); } } diff --git a/src/ImageSharp/MetaData/Profiles/ICC/IccProfile.cs b/src/ImageSharp/MetaData/Profiles/ICC/IccProfile.cs index db1d96d7ec..2b2fe1e4ec 100644 --- a/src/ImageSharp/MetaData/Profiles/ICC/IccProfile.cs +++ b/src/ImageSharp/MetaData/Profiles/ICC/IccProfile.cs @@ -149,17 +149,6 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Icc #endif - /// - /// Extends the profile with additional data. - /// - /// The array containing addition profile data. - public void Extend(byte[] bytes) - { - int currentLength = this.data.Length; - Array.Resize(ref this.data, currentLength + bytes.Length); - Buffer.BlockCopy(bytes, 0, this.data, currentLength, bytes.Length); - } - /// /// Checks for signs of a corrupt profile. /// diff --git a/src/ImageSharp/PixelFormats/Bgra32.cs b/src/ImageSharp/PixelFormats/Bgra32.cs index f951be8811..14b2da07c9 100644 --- a/src/ImageSharp/PixelFormats/Bgra32.cs +++ b/src/ImageSharp/PixelFormats/Bgra32.cs @@ -11,6 +11,7 @@ namespace SixLabors.ImageSharp.PixelFormats /// /// Packed pixel type containing four 8-bit unsigned normalized values ranging from 0 to 255. /// The color components are stored in blue, green, red, and alpha order (least significant to most significant byte). + /// The format is binary compatible with System.Drawing.Imaging.PixelFormat.Format32bppArgb /// /// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form. /// diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs index 6828f11dcc..0d8db637de 100644 --- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs +++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs @@ -2,13 +2,15 @@ // Licensed under the Apache License, Version 2.0. // -namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders -{ - using System; - using System.Numerics; - using SixLabors.Memory; +using System; +using System.Numerics; +using System.Buffers; +using SixLabors.ImageSharp.Memory; +using SixLabors.Memory; +namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders +{ /// /// Collection of Porter Duff alpha blending functions applying different composition models. /// @@ -44,7 +46,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -83,7 +85,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -122,7 +124,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -161,7 +163,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -200,7 +202,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -239,7 +241,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -278,7 +280,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -317,7 +319,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -356,7 +358,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -395,7 +397,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -434,7 +436,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -473,7 +475,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -512,7 +514,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -551,7 +553,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -590,7 +592,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -629,7 +631,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -668,7 +670,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -707,7 +709,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -746,7 +748,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -785,7 +787,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -824,7 +826,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt index 07888a756d..4f627764f5 100644 --- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt +++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt @@ -12,13 +12,13 @@ // Licensed under the Apache License, Version 2.0. // +using System; +using System.Numerics; +using System.Buffers; +using SixLabors.Memory; + namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders { - using System; - using System.Numerics; - using SixLabors.ImageSharp.Memory; - - /// /// Collection of Porter Duff alpha blending functions applying different composition models. /// @@ -86,7 +86,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = memoryManager.Allocate(destination.Length * 3, false)) + using (IMemoryOwner buffer = memoryManager.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); diff --git a/src/ImageSharp/Processing/Processors/Binarization/BinaryThresholdProcessor.cs b/src/ImageSharp/Processing/Processors/Binarization/BinaryThresholdProcessor.cs index 57d4e00ae3..c4f4266d98 100644 --- a/src/ImageSharp/Processing/Processors/Binarization/BinaryThresholdProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Binarization/BinaryThresholdProcessor.cs @@ -70,25 +70,27 @@ namespace SixLabors.ImageSharp.Processing.Processors.Binarization bool isAlphaOnly = typeof(TPixel) == typeof(Alpha8); - Parallel.For( + ParallelFor.WithConfiguration( startY, endY, - configuration.ParallelOptions, + configuration, y => - { - Span row = source.GetPixelRowSpan(y); - Rgba32 rgba = default; - - for (int x = startX; x < endX; x++) { - ref TPixel color = ref row[x]; - color.ToRgba32(ref rgba); + Span row = source.GetPixelRowSpan(y); + Rgba32 rgba = default; + + for (int x = startX; x < endX; x++) + { + ref TPixel color = ref row[x]; + color.ToRgba32(ref rgba); - // Convert to grayscale using ITU-R Recommendation BT.709 if required - float luminance = isAlphaOnly ? rgba.A : (.2126F * rgba.R) + (.7152F * rgba.G) + (.0722F * rgba.B); - color = luminance >= threshold ? upper : lower; - } - }); + // Convert to grayscale using ITU-R Recommendation BT.709 if required + float luminance = isAlphaOnly + ? rgba.A + : (.2126F * rgba.R) + (.7152F * rgba.G) + (.0722F * rgba.B); + color = luminance >= threshold ? upper : lower; + } + }); } } } \ No newline at end of file diff --git a/src/ImageSharp/Processing/Processors/Convolution/Convolution2DProcessor.cs b/src/ImageSharp/Processing/Processors/Convolution/Convolution2DProcessor.cs index 57f71a9ce7..b5a2725437 100644 --- a/src/ImageSharp/Processing/Processors/Convolution/Convolution2DProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Convolution/Convolution2DProcessor.cs @@ -5,6 +5,7 @@ using System; using System.Numerics; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; using SixLabors.Memory; @@ -61,10 +62,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution { source.CopyTo(targetPixels); - Parallel.For( + ParallelFor.WithConfiguration( startY, endY, - configuration.ParallelOptions, + configuration, y => { Span sourceRow = source.GetPixelRowSpan(y); diff --git a/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs b/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs index 6d7147cf7e..07b2ed064e 100644 --- a/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs @@ -4,6 +4,8 @@ using System; using System.Numerics; using System.Threading.Tasks; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; using SixLabors.ImageSharp.Processing.Processors; @@ -43,12 +45,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution /// protected override void OnFrameApply(ImageFrame source, Rectangle sourceRectangle, Configuration configuration) { - ParallelOptions parallelOptions = configuration.ParallelOptions; - using (Buffer2D firstPassPixels = configuration.MemoryAllocator.Allocate2D(source.Size())) { - this.ApplyConvolution(firstPassPixels, source.PixelBuffer, source.Bounds(), this.KernelX, parallelOptions); - this.ApplyConvolution(source.PixelBuffer, firstPassPixels, sourceRectangle, this.KernelY, parallelOptions); + this.ApplyConvolution(firstPassPixels, source.PixelBuffer, source.Bounds(), this.KernelX, configuration); + this.ApplyConvolution(source.PixelBuffer, firstPassPixels, sourceRectangle, this.KernelY, configuration); } } @@ -62,13 +62,13 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution /// The structure that specifies the portion of the image object to draw. /// /// The kernel operator. - /// The parallel options + /// The private void ApplyConvolution( Buffer2D targetPixels, Buffer2D sourcePixels, Rectangle sourceRectangle, DenseMatrix kernel, - ParallelOptions parallelOptions) + Configuration configuration) { int kernelHeight = kernel.Rows; int kernelWidth = kernel.Columns; @@ -82,10 +82,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution int maxY = endY - 1; int maxX = endX - 1; - Parallel.For( + ParallelFor.WithConfiguration( startY, endY, - parallelOptions, + configuration, y => { Span targetRow = targetPixels.GetRowSpan(y); diff --git a/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor.cs b/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor.cs index 84a166545a..31e638a0ad 100644 --- a/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor.cs @@ -5,6 +5,7 @@ using System; using System.Numerics; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; using SixLabors.ImageSharp.Processing.Processors; @@ -51,10 +52,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution { source.CopyTo(targetPixels); - Parallel.For( + ParallelFor.WithConfiguration( startY, endY, - configuration.ParallelOptions, + configuration, y => { Span sourceRow = source.GetPixelRowSpan(y); diff --git a/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor.cs b/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor.cs index 22297b8f20..316de422f5 100644 --- a/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor.cs @@ -6,6 +6,8 @@ using System.Numerics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Threading.Tasks; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; using SixLabors.ImageSharp.Processing.Processors.Filters; @@ -133,10 +135,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution Buffer2D passPixels = pass.PixelBuffer; Buffer2D targetPixels = source.PixelBuffer; - Parallel.For( + ParallelFor.WithConfiguration( minY, maxY, - configuration.ParallelOptions, + configuration, y => { int offsetY = y - shiftY; diff --git a/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor.cs b/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor.cs index b9329f4df6..59898e9fc1 100644 --- a/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor.cs @@ -5,6 +5,7 @@ using System; using System.Numerics; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -69,10 +70,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Effects { source.CopyTo(targetPixels); - Parallel.For( + ParallelFor.WithConfiguration( startY, maxY, - configuration.ParallelOptions, + configuration, y => { Span sourceRow = source.GetPixelRowSpan(y); diff --git a/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs b/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs index 56085e76c3..50f76efed7 100644 --- a/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs @@ -73,7 +73,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Effects Parallel.ForEach( range, - configuration.ParallelOptions, + configuration.GetParallelOptions(), y => { int offsetY = y - startY; diff --git a/src/ImageSharp/Processing/Processors/Filters/FilterProcessor.cs b/src/ImageSharp/Processing/Processors/Filters/FilterProcessor.cs index e8a1fc9cb8..6244d8bf76 100644 --- a/src/ImageSharp/Processing/Processors/Filters/FilterProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Filters/FilterProcessor.cs @@ -41,10 +41,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters int endX = interest.Right; Matrix4x4 matrix = this.Matrix; - Parallel.For( + ParallelFor.WithConfiguration( startY, endY, - configuration.ParallelOptions, + configuration, y => { Span row = source.GetPixelRowSpan(y); diff --git a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistEqualizationProcessor.cs b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistEqualizationProcessor.cs index 62f1d18b9c..c494980861 100644 --- a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistEqualizationProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistEqualizationProcessor.cs @@ -2,10 +2,10 @@ // Licensed under the Apache License, Version 2.0. using System; -using System.Collections.Generic; using System.Numerics; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -51,15 +51,15 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization int halfGridSize = this.GridSize / 2; using (Buffer2D targetPixels = configuration.MemoryAllocator.Allocate2D(source.Width, source.Height)) { - Parallel.For( + ParallelFor.WithConfiguration( 0, source.Width, - configuration.ParallelOptions, + Configuration.Default, x => { - using (IBuffer histogramBuffer = memoryAllocator.AllocateClean(this.LuminanceLevels)) - using (IBuffer histogramBufferCopy = memoryAllocator.AllocateClean(this.LuminanceLevels)) - using (IBuffer cdfBuffer = memoryAllocator.AllocateClean(this.LuminanceLevels)) + using (System.Buffers.IMemoryOwner histogramBuffer = memoryAllocator.Allocate(this.LuminanceLevels, AllocationOptions.Clean)) + using (System.Buffers.IMemoryOwner histogramBufferCopy = memoryAllocator.Allocate(this.LuminanceLevels, AllocationOptions.Clean)) + using (System.Buffers.IMemoryOwner cdfBuffer = memoryAllocator.Allocate(this.LuminanceLevels, AllocationOptions.Clean)) { Span histogram = histogramBuffer.GetSpan(); Span histogramCopy = histogramBufferCopy.GetSpan(); @@ -69,7 +69,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization // Build the histogram of grayscale values for the current grid. for (int dy = -halfGridSize; dy < halfGridSize; dy++) { - Span rowSpan = this.GetPixelRow(source, x - halfGridSize, dy, this.GridSize); + Span rowSpan = this.GetPixelRow(source, (int)x - halfGridSize, dy, this.GridSize); int maxIdx = this.AddPixelsTooHistogram(rowSpan, histogram, this.LuminanceLevels); if (maxIdx > maxHistIdx) { diff --git a/src/ImageSharp/Processing/Processors/Normalization/GlobalHistogramEqualizationProcessor.cs b/src/ImageSharp/Processing/Processors/Normalization/GlobalHistogramEqualizationProcessor.cs index cdf1f43c08..1d6042d8da 100644 --- a/src/ImageSharp/Processing/Processors/Normalization/GlobalHistogramEqualizationProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Normalization/GlobalHistogramEqualizationProcessor.cs @@ -4,6 +4,7 @@ using System; using System.Numerics; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -36,8 +37,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization int numberOfPixels = source.Width * source.Height; Span pixels = source.GetPixelSpan(); - using (IBuffer histogramBuffer = memoryAllocator.AllocateClean(this.LuminanceLevels)) - using (IBuffer cdfBuffer = memoryAllocator.AllocateClean(this.LuminanceLevels)) + using (System.Buffers.IMemoryOwner histogramBuffer = memoryAllocator.Allocate(this.LuminanceLevels, AllocationOptions.Clean)) + using (System.Buffers.IMemoryOwner cdfBuffer = memoryAllocator.Allocate(this.LuminanceLevels, AllocationOptions.Clean)) { // Build the histogram of the grayscale levels. Span histogram = histogramBuffer.GetSpan(); diff --git a/src/ImageSharp/Processing/Processors/Normalization/HistogramEqualizationProcessor.cs b/src/ImageSharp/Processing/Processors/Normalization/HistogramEqualizationProcessor.cs index 4928a54674..a86c8b6183 100644 --- a/src/ImageSharp/Processing/Processors/Normalization/HistogramEqualizationProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Normalization/HistogramEqualizationProcessor.cs @@ -2,6 +2,11 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; +using System.Numerics; +using System.Runtime.CompilerServices; +using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; namespace SixLabors.ImageSharp.Processing.Processors.Normalization diff --git a/src/ImageSharp/Processing/Processors/Overlays/BackgroundColorProcessor.cs b/src/ImageSharp/Processing/Processors/Overlays/BackgroundColorProcessor.cs index 797d388c04..c7fa2ff19c 100644 --- a/src/ImageSharp/Processing/Processors/Overlays/BackgroundColorProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Overlays/BackgroundColorProcessor.cs @@ -2,8 +2,10 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -65,8 +67,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays int width = maxX - minX; - using (IBuffer colors = source.MemoryAllocator.Allocate(width)) - using (IBuffer amount = source.MemoryAllocator.Allocate(width)) + using (IMemoryOwner colors = source.MemoryAllocator.Allocate(width)) + using (IMemoryOwner amount = source.MemoryAllocator.Allocate(width)) { // Be careful! Do not capture colorSpan & amountSpan in the lambda below! Span colorSpan = colors.GetSpan(); @@ -80,10 +82,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays } PixelBlender blender = PixelOperations.Instance.GetPixelBlender(this.GraphicsOptions.BlenderMode); - Parallel.For( + ParallelFor.WithConfiguration( minY, maxY, - configuration.ParallelOptions, + configuration, y => { Span destination = source.GetPixelRowSpan(y - startY).Slice(minX - startX, width); diff --git a/src/ImageSharp/Processing/Processors/Overlays/GlowProcessor.cs b/src/ImageSharp/Processing/Processors/Overlays/GlowProcessor.cs index 023643520d..6042493310 100644 --- a/src/ImageSharp/Processing/Processors/Overlays/GlowProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Overlays/GlowProcessor.cs @@ -2,9 +2,11 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Numerics; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; using SixLabors.Memory; @@ -111,7 +113,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays } int width = maxX - minX; - using (IBuffer rowColors = source.MemoryAllocator.Allocate(width)) + using (IMemoryOwner rowColors = source.MemoryAllocator.Allocate(width)) { // Be careful! Do not capture rowColorsSpan in the lambda below! Span rowColorsSpan = rowColors.GetSpan(); @@ -121,27 +123,25 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays rowColorsSpan[i] = glowColor; } - Parallel.For( + ParallelFor.WithTemporaryBuffer( minY, maxY, - configuration.ParallelOptions, - y => + configuration, + width, + (y, amounts) => { - using (IBuffer amounts = source.MemoryAllocator.Allocate(width)) + Span amountsSpan = amounts.GetSpan(); + int offsetY = y - startY; + int offsetX = minX - startX; + for (int i = 0; i < width; i++) { - Span amountsSpan = amounts.GetSpan(); - int offsetY = y - startY; - int offsetX = minX - startX; - for (int i = 0; i < width; i++) - { - float distance = Vector2.Distance(center, new Vector2(i + offsetX, offsetY)); - amountsSpan[i] = (this.GraphicsOptions.BlendPercentage * (1 - (.95F * (distance / maxDistance)))).Clamp(0, 1); - } - - Span destination = source.GetPixelRowSpan(offsetY).Slice(offsetX, width); - - this.blender.Blend(source.MemoryAllocator, destination, destination, rowColors.GetSpan(), amountsSpan); + float distance = Vector2.Distance(center, new Vector2(i + offsetX, offsetY)); + amountsSpan[i] = (this.GraphicsOptions.BlendPercentage * (1 - (.95F * (distance / maxDistance)))).Clamp(0, 1); } + + Span destination = source.GetPixelRowSpan(offsetY).Slice(offsetX, width); + + this.blender.Blend(source.MemoryAllocator, destination, destination, rowColors.GetSpan(), amountsSpan); }); } } diff --git a/src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor.cs b/src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor.cs index 3789e6bf83..b8bd6c5a53 100644 --- a/src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor.cs @@ -2,9 +2,11 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Numerics; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; using SixLabors.Memory; @@ -113,7 +115,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays } int width = maxX - minX; - using (IBuffer rowColors = source.MemoryAllocator.Allocate(width)) + using (IMemoryOwner rowColors = source.MemoryAllocator.Allocate(width)) { // Be careful! Do not capture rowColorsSpan in the lambda below! Span rowColorsSpan = rowColors.GetSpan(); @@ -123,27 +125,33 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays rowColorsSpan[i] = vignetteColor; } - Parallel.For( + ParallelFor.WithTemporaryBuffer( minY, maxY, - configuration.ParallelOptions, - y => + configuration, + width, + (y, amounts) => { - using (IBuffer amounts = source.MemoryAllocator.Allocate(width)) + Span amountsSpan = amounts.GetSpan(); + int offsetY = y - startY; + int offsetX = minX - startX; + for (int i = 0; i < width; i++) { - Span amountsSpan = amounts.GetSpan(); - int offsetY = y - startY; - int offsetX = minX - startX; - for (int i = 0; i < width; i++) - { - float distance = Vector2.Distance(centre, new Vector2(i + offsetX, offsetY)); - amountsSpan[i] = (this.GraphicsOptions.BlendPercentage * (.9F * (distance / maxDistance))).Clamp(0, 1); - } - - Span destination = source.GetPixelRowSpan(offsetY).Slice(offsetX, width); - - this.blender.Blend(source.MemoryAllocator, destination, destination, rowColors.GetSpan(), amountsSpan); + float distance = Vector2.Distance(centre, new Vector2(i + offsetX, offsetY)); + amountsSpan[i] = + (this.GraphicsOptions.BlendPercentage * (.9F * (distance / maxDistance))).Clamp( + 0, + 1); } + + Span destination = source.GetPixelRowSpan(offsetY).Slice(offsetX, width); + + this.blender.Blend( + source.MemoryAllocator, + destination, + destination, + rowColors.GetSpan(), + amountsSpan); }); } } diff --git a/src/ImageSharp/Processing/Processors/Quantization/QuantizedFrame{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/QuantizedFrame{TPixel}.cs index 977b939a1c..2e3bb2c419 100644 --- a/src/ImageSharp/Processing/Processors/Quantization/QuantizedFrame{TPixel}.cs +++ b/src/ImageSharp/Processing/Processors/Quantization/QuantizedFrame{TPixel}.cs @@ -2,6 +2,9 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -15,7 +18,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization public class QuantizedFrame : IDisposable where TPixel : struct, IPixel { - private IBuffer pixels; + private IMemoryOwner pixels; /// /// Initializes a new instance of the class. @@ -32,7 +35,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization this.Width = width; this.Height = height; this.Palette = palette; - this.pixels = memoryAllocator.AllocateCleanManagedByteBuffer(width * height); + this.pixels = memoryAllocator.AllocateManagedByteBuffer(width * height, AllocationOptions.Clean); } /// diff --git a/src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs index 7c2ff77e36..619107f971 100644 --- a/src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs +++ b/src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs @@ -2,11 +2,13 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Collections.Generic; using System.Numerics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; @@ -70,37 +72,37 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization /// /// Moment of P(c). /// - private IBuffer vwt; + private IMemoryOwner vwt; /// /// Moment of r*P(c). /// - private IBuffer vmr; + private IMemoryOwner vmr; /// /// Moment of g*P(c). /// - private IBuffer vmg; + private IMemoryOwner vmg; /// /// Moment of b*P(c). /// - private IBuffer vmb; + private IMemoryOwner vmb; /// /// Moment of a*P(c). /// - private IBuffer vma; + private IMemoryOwner vma; /// /// Moment of c^2*P(c). /// - private IBuffer m2; + private IMemoryOwner m2; /// /// Color space tag. /// - private IBuffer tag; + private IMemoryOwner tag; /// /// Maximum allowed color depth @@ -139,13 +141,13 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization try { - this.vwt = memoryAllocator.AllocateClean(TableLength); - this.vmr = memoryAllocator.AllocateClean(TableLength); - this.vmg = memoryAllocator.AllocateClean(TableLength); - this.vmb = memoryAllocator.AllocateClean(TableLength); - this.vma = memoryAllocator.AllocateClean(TableLength); - this.m2 = memoryAllocator.AllocateClean(TableLength); - this.tag = memoryAllocator.AllocateClean(TableLength); + this.vwt = memoryAllocator.Allocate(TableLength, AllocationOptions.Clean); + this.vmr = memoryAllocator.Allocate(TableLength, AllocationOptions.Clean); + this.vmg = memoryAllocator.Allocate(TableLength, AllocationOptions.Clean); + this.vmb = memoryAllocator.Allocate(TableLength, AllocationOptions.Clean); + this.vma = memoryAllocator.Allocate(TableLength, AllocationOptions.Clean); + this.m2 = memoryAllocator.Allocate(TableLength, AllocationOptions.Clean); + this.tag = memoryAllocator.Allocate(TableLength, AllocationOptions.Clean); return base.QuantizeFrame(image); } @@ -467,18 +469,18 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization Span vmaSpan = this.vma.GetSpan(); Span m2Span = this.m2.GetSpan(); - using (IBuffer volume = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) - using (IBuffer volumeR = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) - using (IBuffer volumeG = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) - using (IBuffer volumeB = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) - using (IBuffer volumeA = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) - using (IBuffer volume2 = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) - using (IBuffer area = memoryAllocator.Allocate(IndexAlphaCount)) - using (IBuffer areaR = memoryAllocator.Allocate(IndexAlphaCount)) - using (IBuffer areaG = memoryAllocator.Allocate(IndexAlphaCount)) - using (IBuffer areaB = memoryAllocator.Allocate(IndexAlphaCount)) - using (IBuffer areaA = memoryAllocator.Allocate(IndexAlphaCount)) - using (IBuffer area2 = memoryAllocator.Allocate(IndexAlphaCount)) + using (IMemoryOwner volume = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) + using (IMemoryOwner volumeR = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) + using (IMemoryOwner volumeG = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) + using (IMemoryOwner volumeB = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) + using (IMemoryOwner volumeA = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) + using (IMemoryOwner volume2 = memoryAllocator.Allocate(IndexCount * IndexAlphaCount)) + using (IMemoryOwner area = memoryAllocator.Allocate(IndexAlphaCount)) + using (IMemoryOwner areaR = memoryAllocator.Allocate(IndexAlphaCount)) + using (IMemoryOwner areaG = memoryAllocator.Allocate(IndexAlphaCount)) + using (IMemoryOwner areaB = memoryAllocator.Allocate(IndexAlphaCount)) + using (IMemoryOwner areaA = memoryAllocator.Allocate(IndexAlphaCount)) + using (IMemoryOwner area2 = memoryAllocator.Allocate(IndexAlphaCount)) { Span volumeSpan = volume.GetSpan(); Span volumeRSpan = volumeR.GetSpan(); @@ -791,7 +793,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization this.colorCube = new Box[this.colors]; float[] vv = new float[this.colors]; - ref var cube = ref this.colorCube[0]; + ref Box cube = ref this.colorCube[0]; cube.R0 = cube.G0 = cube.B0 = cube.A0 = 0; cube.R1 = cube.G1 = cube.B1 = IndexCount - 1; cube.A1 = IndexAlphaCount - 1; @@ -800,8 +802,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization for (int i = 1; i < this.colors; i++) { - ref var nextCube = ref this.colorCube[next]; - ref var currentCube = ref this.colorCube[i]; + ref Box nextCube = ref this.colorCube[next]; + ref Box currentCube = ref this.colorCube[i]; if (this.Cut(ref nextCube, ref currentCube)) { vv[next] = nextCube.Volume > 1 ? this.Variance(ref nextCube) : 0F; diff --git a/src/ImageSharp/Processing/Processors/Transforms/AffineTransformProcessor.cs b/src/ImageSharp/Processing/Processors/Transforms/AffineTransformProcessor.cs index d9f35c8929..3993ab1a8d 100644 --- a/src/ImageSharp/Processing/Processors/Transforms/AffineTransformProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Transforms/AffineTransformProcessor.cs @@ -9,6 +9,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -77,10 +78,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms if (this.Sampler is NearestNeighborResampler) { - Parallel.For( + ParallelFor.WithConfiguration( 0, height, - configuration.ParallelOptions, + configuration, y => { Span destRow = destination.GetPixelRowSpan(y); @@ -115,10 +116,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms using (Buffer2D yBuffer = memoryAllocator.Allocate2D(yLength, height)) using (Buffer2D xBuffer = memoryAllocator.Allocate2D(xLength, height)) { - Parallel.For( + ParallelFor.WithConfiguration( 0, height, - configuration.ParallelOptions, + configuration, y => { ref TPixel destRowRef = ref MemoryMarshal.GetReference(destination.GetPixelRowSpan(y)); diff --git a/src/ImageSharp/Processing/Processors/Transforms/CropProcessor.cs b/src/ImageSharp/Processing/Processors/Transforms/CropProcessor.cs index 5d714eef54..0c52123755 100644 --- a/src/ImageSharp/Processing/Processors/Transforms/CropProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Transforms/CropProcessor.cs @@ -58,10 +58,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms int minX = Math.Max(this.CropRectangle.X, sourceRectangle.X); int maxX = Math.Min(this.CropRectangle.Right, sourceRectangle.Right); - Parallel.For( + ParallelFor.WithConfiguration( minY, maxY, - configuration.ParallelOptions, + configuration, y => { Span sourceRow = source.GetPixelRowSpan(y).Slice(minX); diff --git a/src/ImageSharp/Processing/Processors/Transforms/FlipProcessor.cs b/src/ImageSharp/Processing/Processors/Transforms/FlipProcessor.cs index 4ab4971b8c..cea6df391f 100644 --- a/src/ImageSharp/Processing/Processors/Transforms/FlipProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Transforms/FlipProcessor.cs @@ -4,6 +4,7 @@ using System; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -58,10 +59,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms using (Buffer2D targetPixels = configuration.MemoryAllocator.Allocate2D(source.Size())) { - Parallel.For( + ParallelFor.WithConfiguration( 0, halfHeight, - configuration.ParallelOptions, + configuration, y => { int newY = height - y - 1; @@ -91,10 +92,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms using (Buffer2D targetPixels = configuration.MemoryAllocator.Allocate2D(source.Size())) { - Parallel.For( + ParallelFor.WithConfiguration( 0, height, - configuration.ParallelOptions, + configuration, y => { Span sourceRow = source.GetPixelRowSpan(y); diff --git a/src/ImageSharp/Processing/Processors/Transforms/ProjectiveTransformProcessor.cs b/src/ImageSharp/Processing/Processors/Transforms/ProjectiveTransformProcessor.cs index 716133fb71..042ce2ff6d 100644 --- a/src/ImageSharp/Processing/Processors/Transforms/ProjectiveTransformProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Transforms/ProjectiveTransformProcessor.cs @@ -9,6 +9,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -74,10 +75,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms if (this.Sampler is NearestNeighborResampler) { - Parallel.For( + ParallelFor.WithConfiguration( 0, height, - configuration.ParallelOptions, + configuration, y => { Span destRow = destination.GetPixelRowSpan(y); @@ -120,10 +121,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms using (Buffer2D yBuffer = memoryAllocator.Allocate2D(yLength, height)) using (Buffer2D xBuffer = memoryAllocator.Allocate2D(xLength, height)) { - Parallel.For( + ParallelFor.WithConfiguration( 0, height, - configuration.ParallelOptions, + configuration, y => { ref TPixel destRowRef = ref MemoryMarshal.GetReference(destination.GetPixelRowSpan(y)); diff --git a/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs b/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs index 8c9ab9a23d..fd3c34d6c1 100644 --- a/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs @@ -2,6 +2,7 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Collections.Generic; using System.Linq; using System.Numerics; @@ -9,6 +10,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Threading.Tasks; using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Memory; using SixLabors.Primitives; @@ -269,10 +271,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms float widthFactor = sourceRectangle.Width / (float)this.ResizeRectangle.Width; float heightFactor = sourceRectangle.Height / (float)this.ResizeRectangle.Height; - Parallel.For( + ParallelFor.WithConfiguration( minY, maxY, - configuration.ParallelOptions, + configuration, y => { // Y coordinates of source points @@ -296,14 +298,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms // TODO: Using a transposed variant of 'firstPassPixels' could eliminate the need for the WeightsWindow.ComputeWeightedColumnSum() method, and improve speed! using (Buffer2D firstPassPixels = source.MemoryAllocator.Allocate2D(width, source.Height)) { - firstPassPixels.Buffer.Clear(); + firstPassPixels.MemorySource.Clear(); ParallelFor.WithTemporaryBuffer( 0, sourceRectangle.Bottom, configuration, source.Width, - (int y, IBuffer tempRowBuffer) => + (int y, IMemoryOwner tempRowBuffer) => { ref Vector4 firstPassRow = ref MemoryMarshal.GetReference(firstPassPixels.GetRowSpan(y)); Span sourceRow = source.GetPixelRowSpan(y); @@ -330,10 +332,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms }); // Now process the rows. - Parallel.For( + ParallelFor.WithConfiguration( minY, maxY, - configuration.ParallelOptions, + configuration, y => { // Ensure offsets are normalized for cropping and padding. diff --git a/src/ImageSharp/Processing/Processors/Transforms/RotateProcessor.cs b/src/ImageSharp/Processing/Processors/Transforms/RotateProcessor.cs index d57e9cbd95..b18d882c24 100644 --- a/src/ImageSharp/Processing/Processors/Transforms/RotateProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Transforms/RotateProcessor.cs @@ -147,10 +147,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms int height = source.Height; Rectangle destinationBounds = destination.Bounds(); - Parallel.For( + ParallelFor.WithConfiguration( 0, height, - configuration.ParallelOptions, + configuration, y => { Span sourceRow = source.GetPixelRowSpan(y); @@ -179,10 +179,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms int width = source.Width; int height = source.Height; - Parallel.For( + ParallelFor.WithConfiguration( 0, height, - configuration.ParallelOptions, + configuration, y => { Span sourceRow = source.GetPixelRowSpan(y); @@ -207,10 +207,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms int height = source.Height; Rectangle destinationBounds = destination.Bounds(); - Parallel.For( + ParallelFor.WithConfiguration( 0, height, - configuration.ParallelOptions, + configuration, y => { Span sourceRow = source.GetPixelRowSpan(y); diff --git a/src/ImageSharp/Processing/Processors/Transforms/WeightsBuffer.cs b/src/ImageSharp/Processing/Processors/Transforms/WeightsBuffer.cs index 581a3353ae..68133a5489 100644 --- a/src/ImageSharp/Processing/Processors/Transforms/WeightsBuffer.cs +++ b/src/ImageSharp/Processing/Processors/Transforms/WeightsBuffer.cs @@ -2,6 +2,8 @@ // Licensed under the Apache License, Version 2.0. using System; + +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; namespace SixLabors.ImageSharp.Processing.Processors.Transforms @@ -21,7 +23,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms /// The size of the destination window public WeightsBuffer(MemoryAllocator memoryAllocator, int sourceSize, int destinationSize) { - this.dataBuffer = memoryAllocator.Allocate2D(sourceSize, destinationSize, true); + this.dataBuffer = memoryAllocator.Allocate2D(sourceSize, destinationSize, AllocationOptions.Clean); this.Weights = new WeightsWindow[destinationSize]; } diff --git a/src/ImageSharp/Processing/Processors/Transforms/WeightsWindow.cs b/src/ImageSharp/Processing/Processors/Transforms/WeightsWindow.cs index ebf2db4bf0..01cf97e591 100644 --- a/src/ImageSharp/Processing/Processors/Transforms/WeightsWindow.cs +++ b/src/ImageSharp/Processing/Processors/Transforms/WeightsWindow.cs @@ -2,9 +2,12 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Numerics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; + +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; namespace SixLabors.ImageSharp.Processing.Processors.Transforms @@ -32,7 +35,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms /// /// The buffer containing the weights values. /// - private readonly IBuffer buffer; + private readonly MemorySource buffer; /// /// Initializes a new instance of the struct. @@ -46,7 +49,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms { this.flatStartIndex = (index * buffer.Width) + left; this.Left = left; - this.buffer = buffer.Buffer; + this.buffer = buffer.MemorySource; this.Length = length; } @@ -66,7 +69,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms /// /// The [MethodImpl(MethodImplOptions.AggressiveInlining)] - public Span GetWindowSpan() => this.buffer.Slice(this.flatStartIndex, this.Length); + public Span GetWindowSpan() => this.buffer.GetSpan().Slice(this.flatStartIndex, this.Length); /// /// Computes the sum of vectors in 'rowSpan' weighted by weight values, pointed by this instance. diff --git a/tests/ImageSharp.Benchmarks/Codecs/CopyPixels.cs b/tests/ImageSharp.Benchmarks/Codecs/CopyPixels.cs index 8bf87fb628..d55c231a73 100644 --- a/tests/ImageSharp.Benchmarks/Codecs/CopyPixels.cs +++ b/tests/ImageSharp.Benchmarks/Codecs/CopyPixels.cs @@ -1,19 +1,17 @@ -// -// Copyright (c) James Jackson-South and contributors. +// Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. -// +using System; +using System.Threading.Tasks; + +using BenchmarkDotNet.Attributes; + +using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; namespace SixLabors.ImageSharp.Benchmarks.Codecs { - using System; - using System.Threading.Tasks; - - using BenchmarkDotNet.Attributes; - using SixLabors.ImageSharp.Advanced; - using SixLabors.Memory; - public class CopyPixels : BenchmarkBase { [Benchmark(Baseline = true, Description = "PixelAccessor Copy by indexer")] @@ -24,10 +22,10 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs { Buffer2D sourcePixels = source.GetRootFramePixelBuffer(); Buffer2D targetPixels = target.GetRootFramePixelBuffer(); - Parallel.For( + ParallelFor.WithConfiguration( 0, source.Height, - Configuration.Default.ParallelOptions, + Configuration.Default, y => { for (int x = 0; x < source.Width; x++) @@ -48,10 +46,10 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs { Buffer2D sourcePixels = source.GetRootFramePixelBuffer(); Buffer2D targetPixels = target.GetRootFramePixelBuffer(); - Parallel.For( + ParallelFor.WithConfiguration( 0, source.Height, - Configuration.Default.ParallelOptions, + Configuration.Default, y => { Span sourceRow = sourcePixels.GetRowSpan(y); @@ -73,17 +71,17 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs using (var source = new Image(1024, 768)) using (var target = new Image(1024, 768)) { - Parallel.For( + ParallelFor.WithConfiguration( 0, source.Height, - Configuration.Default.ParallelOptions, + Configuration.Default, y => - { - for (int x = 0; x < source.Width; x++) { - target[x, y] = source[x, y]; - } - }); + for (int x = 0; x < source.Width; x++) + { + target[x, y] = source[x, y]; + } + }); return target[0, 0]; } @@ -95,23 +93,23 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs using (var source = new Image(1024, 768)) using (var target = new Image(1024, 768)) { - Parallel.For( + ParallelFor.WithConfiguration( 0, source.Height, - Configuration.Default.ParallelOptions, + Configuration.Default, y => - { - Span sourceRow = source.Frames.RootFrame.GetPixelRowSpan(y); - Span targetRow = target.Frames.RootFrame.GetPixelRowSpan(y); - - for (int x = 0; x < source.Width; x++) { - targetRow[x] = sourceRow[x]; - } - }); + Span sourceRow = source.Frames.RootFrame.GetPixelRowSpan(y); + Span targetRow = target.Frames.RootFrame.GetPixelRowSpan(y); + + for (int x = 0; x < source.Width; x++) + { + targetRow[x] = sourceRow[x]; + } + }); return target[0, 0]; } } } -} +} \ No newline at end of file diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg.cs index f86919dd15..9b968e4db3 100644 --- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg.cs +++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg.cs @@ -4,8 +4,8 @@ using System.Drawing; using System.IO; using BenchmarkDotNet.Attributes; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; + +using SixLabors.ImageSharp.Formats.Jpeg; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Tests; using CoreSize = SixLabors.Primitives.Size; @@ -45,23 +45,11 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg } [Benchmark(Description = "Decode Jpeg - ImageSharp")] - public CoreSize JpegImageSharpOrig() - { - using (var memoryStream = new MemoryStream(this.jpegBytes)) - { - using (var image = Image.Load(memoryStream, new GolangJpegDecoder())) - { - return new CoreSize(image.Width, image.Height); - } - } - } - - [Benchmark(Description = "Decode Jpeg - ImageSharp PdfJs")] - public CoreSize JpegImageSharpPdfJs() + public CoreSize JpegImageSharp() { using (var memoryStream = new MemoryStream(this.jpegBytes)) { - using (var image = Image.Load(memoryStream, new PdfJsJpegDecoder())) + using (var image = Image.Load(memoryStream, new JpegDecoder())) { return new CoreSize(image.Width, image.Height); } diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegMultiple.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegMultiple.cs index c4ee732f5e..be0fe76b82 100644 --- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegMultiple.cs +++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegMultiple.cs @@ -3,8 +3,7 @@ using System.Collections.Generic; using BenchmarkDotNet.Attributes; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; +using SixLabors.ImageSharp.Formats.Jpeg; using SixLabors.ImageSharp.PixelFormats; using SDImage = System.Drawing.Image; @@ -22,15 +21,9 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg protected override IEnumerable SearchPatterns => new[] { "*.jpg" }; [Benchmark(Description = "DecodeJpegMultiple - ImageSharp")] - public void DecodeJpegImageSharpOrig() + public void DecodeJpegImageSharp() { - this.ForEachStream(ms => Image.Load(ms, new GolangJpegDecoder())); - } - - [Benchmark(Description = "DecodeJpegMultiple - ImageSharp PDFJs")] - public void DecodeJpegImageSharpPdfJs() - { - this.ForEachStream(ms => Image.Load(ms, new PdfJsJpegDecoder())); + this.ForEachStream(ms => Image.Load(ms, new JpegDecoder())); } [Benchmark(Baseline = true, Description = "DecodeJpegMultiple - System.Drawing")] diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs index 059f312b3e..5958b9f79d 100644 --- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs +++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs @@ -5,7 +5,6 @@ using BenchmarkDotNet.Attributes; using System.Drawing; using System.IO; using SixLabors.ImageSharp.Formats.Jpeg; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; using SixLabors.ImageSharp.Tests; namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg @@ -38,12 +37,12 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg } } - [Benchmark(Description = "PdfJsJpegDecoderCore.ParseStream")] + [Benchmark(Description = "JpegDecoderCore.ParseStream")] public void ParseStreamPdfJs() { using (var memoryStream = new MemoryStream(this.jpegBytes)) { - var decoder = new PdfJsJpegDecoderCore(Configuration.Default, new JpegDecoder() { IgnoreMetadata = true }); + var decoder = new JpegDecoderCore(Configuration.Default, new Formats.Jpeg.JpegDecoder() { IgnoreMetadata = true }); decoder.ParseStream(memoryStream); decoder.Dispose(); } diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DoubleBufferedStreams.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DoubleBufferedStreams.cs index f91595df8b..d4cbe81e16 100644 --- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DoubleBufferedStreams.cs +++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DoubleBufferedStreams.cs @@ -4,16 +4,16 @@ using System; using System.IO; using BenchmarkDotNet.Attributes; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components; +using SixLabors.ImageSharp.IO; namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg { [Config(typeof(Config.ShortClr))] public class DoubleBufferedStreams { - private byte[] buffer = CreateTestBytes(); - private byte[] chunk1 = new byte[2]; - private byte[] chunk2 = new byte[2]; + private readonly byte[] buffer = CreateTestBytes(); + private readonly byte[] chunk1 = new byte[2]; + private readonly byte[] chunk2 = new byte[2]; private MemoryStream stream1; private MemoryStream stream2; diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/EncodeJpeg.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/EncodeJpeg.cs index 53f0630b9c..d934a1d6de 100644 --- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/EncodeJpeg.cs +++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/EncodeJpeg.cs @@ -45,7 +45,7 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg [Benchmark(Baseline = true, Description = "System.Drawing Jpeg")] public void JpegSystemDrawing() { - using (MemoryStream memoryStream = new MemoryStream()) + using (var memoryStream = new MemoryStream()) { this.bmpDrawing.Save(memoryStream, ImageFormat.Jpeg); } @@ -54,7 +54,7 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg [Benchmark(Description = "ImageSharp Jpeg")] public void JpegCore() { - using (MemoryStream memoryStream = new MemoryStream()) + using (var memoryStream = new MemoryStream()) { this.bmpCore.SaveAsJpeg(memoryStream); } diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/IdentifyJpeg.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/IdentifyJpeg.cs index b6ad20d128..ae32167a9f 100644 --- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/IdentifyJpeg.cs +++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/IdentifyJpeg.cs @@ -3,8 +3,8 @@ using System.IO; using BenchmarkDotNet.Attributes; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; + +using SixLabors.ImageSharp.Formats.Jpeg; using SixLabors.ImageSharp.Tests; namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg @@ -29,22 +29,11 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg } [Benchmark] - public IImageInfo IdentifyGolang() - { - using (var memoryStream = new MemoryStream(this.jpegBytes)) - { - var decoder = new GolangJpegDecoder(); - - return decoder.Identify(Configuration.Default, memoryStream); - } - } - - [Benchmark] - public IImageInfo IdentifyPdfJs() + public IImageInfo Identify() { using (var memoryStream = new MemoryStream(this.jpegBytes)) { - var decoder = new PdfJsJpegDecoder(); + var decoder = new JpegDecoder(); return decoder.Identify(Configuration.Default, memoryStream); } } diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/LoadResizeSave.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/LoadResizeSave.cs index 296b3fb7a3..77ed828ef1 100644 --- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/LoadResizeSave.cs +++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/LoadResizeSave.cs @@ -26,7 +26,7 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage); [Params( - TestImages.Jpeg.Baseline.Jpeg420Exif + TestImages.Jpeg.Baseline.Jpeg420Exif //, TestImages.Jpeg.Baseline.Calliphora )] public string TestImage { get; set; } @@ -37,7 +37,7 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg [GlobalSetup] public void Setup() { - this.configuration.ParallelOptions.MaxDegreeOfParallelism = + this.configuration.MaxDegreeOfParallelism = this.EnableParallelExecution ? Environment.ProcessorCount : 1; if (this.sourceBytes == null) @@ -74,10 +74,8 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg [Benchmark] public void ImageSharp() { - using (var source = Image.Load( - this.configuration, - this.sourceBytes, - new JpegDecoder { IgnoreMetadata = true })) + var source = Image.Load(this.configuration, this.sourceBytes, new JpegDecoder { IgnoreMetadata = true }); + using (source) using (var destStream = new MemoryStream(this.destBytes)) { source.Mutate(c => c.Resize(source.Width / 4, source.Height / 4)); diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/YCbCrColorConversion.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/YCbCrColorConversion.cs index 5a8a623735..05edd27919 100644 --- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/YCbCrColorConversion.cs +++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/YCbCrColorConversion.cs @@ -1,14 +1,16 @@ -using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. -namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg -{ - using System; - using System.Numerics; +using System; +using System.Numerics; - using BenchmarkDotNet.Attributes; +using BenchmarkDotNet.Attributes; - using SixLabors.Memory; +using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters; +using SixLabors.ImageSharp.Memory; +namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg +{ [Config(typeof(Config.ShortClr))] public class YCbCrColorConversion { @@ -81,6 +83,5 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg return buffers; } - } } \ No newline at end of file diff --git a/tests/ImageSharp.Benchmarks/Color/Bulk/PackFromVector4.cs b/tests/ImageSharp.Benchmarks/Color/Bulk/PackFromVector4.cs index ac396d42e5..a5fa59ba07 100644 --- a/tests/ImageSharp.Benchmarks/Color/Bulk/PackFromVector4.cs +++ b/tests/ImageSharp.Benchmarks/Color/Bulk/PackFromVector4.cs @@ -1,21 +1,27 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + // ReSharper disable InconsistentNaming -namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk -{ - using System.Numerics; - using System.Runtime.CompilerServices; - using System.Runtime.InteropServices; - using BenchmarkDotNet.Attributes; - using SixLabors.Memory; - using SixLabors.ImageSharp.PixelFormats; +using System.Buffers; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +using BenchmarkDotNet.Attributes; +using SixLabors.ImageSharp.Memory; +using SixLabors.ImageSharp.PixelFormats; + +namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk +{ [Config(typeof(Config.ShortClr))] public abstract class PackFromVector4 where TPixel : struct, IPixel { - private IBuffer source; + private IMemoryOwner source; - private IBuffer destination; + private IMemoryOwner destination; [Params(16, 128, 512)] public int Count { get; set; } diff --git a/tests/ImageSharp.Benchmarks/Color/Bulk/PackFromXyzw.cs b/tests/ImageSharp.Benchmarks/Color/Bulk/PackFromXyzw.cs index c4c09f67cd..7e7dfb3652 100644 --- a/tests/ImageSharp.Benchmarks/Color/Bulk/PackFromXyzw.cs +++ b/tests/ImageSharp.Benchmarks/Color/Bulk/PackFromXyzw.cs @@ -1,19 +1,24 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + // ReSharper disable InconsistentNaming -namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk -{ - using System; - using BenchmarkDotNet.Attributes; +using System.Buffers; +using System; - using SixLabors.Memory; - using SixLabors.ImageSharp.PixelFormats; +using BenchmarkDotNet.Attributes; +using SixLabors.ImageSharp.Memory; +using SixLabors.ImageSharp.PixelFormats; + +namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk +{ public abstract class PackFromXyzw where TPixel : struct, IPixel { - private IBuffer destination; + private IMemoryOwner destination; - private IBuffer source; + private IMemoryOwner source; [Params(16, 128, 1024)] public int Count { get; set; } diff --git a/tests/ImageSharp.Benchmarks/Color/Bulk/ToVector4.cs b/tests/ImageSharp.Benchmarks/Color/Bulk/ToVector4.cs index 3b988757d6..50fac25139 100644 --- a/tests/ImageSharp.Benchmarks/Color/Bulk/ToVector4.cs +++ b/tests/ImageSharp.Benchmarks/Color/Bulk/ToVector4.cs @@ -1,20 +1,25 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + // ReSharper disable InconsistentNaming -namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk -{ - using System; - using System.Numerics; - using BenchmarkDotNet.Attributes; +using System.Buffers; +using System; +using System.Numerics; - using SixLabors.Memory; - using SixLabors.ImageSharp.PixelFormats; +using BenchmarkDotNet.Attributes; +using SixLabors.ImageSharp.Memory; +using SixLabors.ImageSharp.PixelFormats; + +namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk +{ public abstract class ToVector4 where TPixel : struct, IPixel { - private IBuffer source; + private IMemoryOwner source; - private IBuffer destination; + private IMemoryOwner destination; [Params(64, 300, 1024)] public int Count { get; set; } diff --git a/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs b/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs index 16743eb73d..4e9c6d10a6 100644 --- a/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs +++ b/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs @@ -1,20 +1,24 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + // ReSharper disable InconsistentNaming -namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk -{ - using System; - using System.Numerics; - using BenchmarkDotNet.Attributes; +using System.Buffers; +using System; - using SixLabors.Memory; - using SixLabors.ImageSharp.PixelFormats; +using BenchmarkDotNet.Attributes; +using SixLabors.ImageSharp.Memory; +using SixLabors.ImageSharp.PixelFormats; + +namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk +{ public abstract class ToXyz where TPixel : struct, IPixel { - private IBuffer source; + private IMemoryOwner source; - private IBuffer destination; + private IMemoryOwner destination; [Params(16, 128, 1024)] public int Count { get; set; } diff --git a/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs b/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs index f947b6e8d8..8166c8f465 100644 --- a/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs +++ b/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs @@ -1,22 +1,23 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading.Tasks; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System; +using System.Buffers; +using BenchmarkDotNet.Attributes; + +using SixLabors.ImageSharp.Memory; +using SixLabors.ImageSharp.PixelFormats; + // ReSharper disable InconsistentNaming namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk { - using BenchmarkDotNet.Attributes; - - using SixLabors.Memory; - using SixLabors.ImageSharp.PixelFormats; - public abstract class ToXyzw where TPixel : struct, IPixel { - private IBuffer source; + private IMemoryOwner source; - private IBuffer destination; + private IMemoryOwner destination; [Params(16, 128, 1024)] public int Count { get; set; } diff --git a/tests/ImageSharp.Benchmarks/ImageSharp.Benchmarks.csproj b/tests/ImageSharp.Benchmarks/ImageSharp.Benchmarks.csproj index 3f67f175fb..35a3a67e9e 100644 --- a/tests/ImageSharp.Benchmarks/ImageSharp.Benchmarks.csproj +++ b/tests/ImageSharp.Benchmarks/ImageSharp.Benchmarks.csproj @@ -18,7 +18,7 @@ - + diff --git a/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs b/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs index 5fe8b2785d..59118a1df3 100644 --- a/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs +++ b/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs @@ -1,30 +1,35 @@ -// -// Copyright (c) James Jackson-South and contributors. +// Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. -// + +using System; +using System.Buffers; +using System.Numerics; + +using BenchmarkDotNet.Attributes; + +using SixLabors.ImageSharp.Memory; +using SixLabors.ImageSharp.PixelFormats; +using SixLabors.ImageSharp.PixelFormats.PixelBlenders; namespace SixLabors.ImageSharp.Benchmarks { - using System; - - using BenchmarkDotNet.Attributes; - using SixLabors.ImageSharp.PixelFormats; using CoreSize = SixLabors.Primitives.Size; - using System.Numerics; - - using SixLabors.Memory; - using SixLabors.ImageSharp.PixelFormats.PixelBlenders; public class PorterDuffBulkVsPixel : BenchmarkBase { - private void BulkVectorConvert(Span destination, Span background, Span source, Span amount) + private void BulkVectorConvert( + Span destination, + Span background, + Span source, + Span amount) where TPixel : struct, IPixel { Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length)); Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); - using (IBuffer buffer = Configuration.Default.MemoryAllocator.Allocate(destination.Length * 3)) + using (IMemoryOwner buffer = + Configuration.Default.MemoryAllocator.Allocate(destination.Length * 3)) { Span destinationSpan = buffer.Slice(0, destination.Length); Span backgroundSpan = buffer.Slice(destination.Length, destination.Length); @@ -41,8 +46,13 @@ namespace SixLabors.ImageSharp.Benchmarks PixelOperations.Instance.PackFromVector4(destinationSpan, destination, destination.Length); } } - private void BulkPixelConvert(Span destination, Span background, Span source, Span amount) - where TPixel : struct, IPixel + + private void BulkPixelConvert( + Span destination, + Span background, + Span source, + Span amount) + where TPixel : struct, IPixel { Guard.MustBeGreaterThanOrEqualTo(destination.Length, background.Length, nameof(destination)); Guard.MustBeGreaterThanOrEqualTo(source.Length, background.Length, nameof(destination)); @@ -59,7 +69,7 @@ namespace SixLabors.ImageSharp.Benchmarks { using (var image = new Image(800, 800)) { - using (IBuffer amounts = Configuration.Default.MemoryAllocator.Allocate(image.Width)) + using (IMemoryOwner amounts = Configuration.Default.MemoryAllocator.Allocate(image.Width)) { amounts.GetSpan().Fill(1); @@ -80,7 +90,7 @@ namespace SixLabors.ImageSharp.Benchmarks { using (var image = new Image(800, 800)) { - using (IBuffer amounts = Configuration.Default.MemoryAllocator.Allocate(image.Width)) + using (IMemoryOwner amounts = Configuration.Default.MemoryAllocator.Allocate(image.Width)) { amounts.GetSpan().Fill(1); Buffer2D pixels = image.GetRootFramePixelBuffer(); @@ -95,4 +105,4 @@ namespace SixLabors.ImageSharp.Benchmarks } } } -} +} \ No newline at end of file diff --git a/tests/ImageSharp.Benchmarks/Samplers/Glow.cs b/tests/ImageSharp.Benchmarks/Samplers/Glow.cs index 85c4fdd7c3..fe1d4221d1 100644 --- a/tests/ImageSharp.Benchmarks/Samplers/Glow.cs +++ b/tests/ImageSharp.Benchmarks/Samplers/Glow.cs @@ -1,27 +1,27 @@ -// -// Copyright (c) James Jackson-South and contributors. +// Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. -// -namespace SixLabors.ImageSharp.Benchmarks -{ +using System; +using System.Buffers; +using System.Numerics; +using System.Threading.Tasks; - using BenchmarkDotNet.Attributes; - using SixLabors.ImageSharp.PixelFormats; +using BenchmarkDotNet.Attributes; - using CoreSize = SixLabors.Primitives.Size; - using System.Numerics; - using System; - using System.Threading.Tasks; +using SixLabors.ImageSharp.Memory; +using SixLabors.ImageSharp.PixelFormats; +using SixLabors.ImageSharp.Processing.Processors; +using SixLabors.ImageSharp.Processing.Processors.Overlays; +using SixLabors.Primitives; - using SixLabors.Memory; - using SixLabors.Primitives; - using SixLabors.ImageSharp.Processing.Processors.Overlays; - using SixLabors.ImageSharp.Processing.Processors; +namespace SixLabors.ImageSharp.Benchmarks +{ + using CoreSize = SixLabors.Primitives.Size; public class Glow : BenchmarkBase { private GlowProcessor bulk; + private GlowProcessorParallel parallel; [GlobalSetup] @@ -29,8 +29,8 @@ namespace SixLabors.ImageSharp.Benchmarks { this.bulk = new GlowProcessor(NamedColors.Beige, 800 * .5f, GraphicsOptions.Default); this.parallel = new GlowProcessorParallel(NamedColors.Beige) { Radius = 800 * .5f, }; - } + [Benchmark(Description = "ImageSharp Glow - Bulk")] public CoreSize GlowBulk() { @@ -74,7 +74,10 @@ namespace SixLabors.ImageSharp.Benchmarks public float Radius { get; set; } /// - protected override void OnFrameApply(ImageFrame source, Rectangle sourceRectangle, Configuration configuration) + protected override void OnFrameApply( + ImageFrame source, + Rectangle sourceRectangle, + Configuration configuration) { int startY = sourceRectangle.Y; int endY = sourceRectangle.Bottom; @@ -82,7 +85,9 @@ namespace SixLabors.ImageSharp.Benchmarks int endX = sourceRectangle.Right; TPixel glowColor = this.GlowColor; Vector2 centre = Rectangle.Center(sourceRectangle); - float maxDistance = this.Radius > 0 ? Math.Min(this.Radius, sourceRectangle.Width * .5F) : sourceRectangle.Width * .5F; + float maxDistance = this.Radius > 0 + ? Math.Min(this.Radius, sourceRectangle.Width * .5F) + : sourceRectangle.Width * .5F; // Align start/end positions. int minX = Math.Max(0, startX); @@ -102,31 +107,36 @@ namespace SixLabors.ImageSharp.Benchmarks } int width = maxX - minX; - using (IBuffer rowColors = Configuration.Default.MemoryAllocator.Allocate(width)) + using (IMemoryOwner rowColors = Configuration.Default.MemoryAllocator.Allocate(width)) { Buffer2D sourcePixels = source.PixelBuffer; rowColors.GetSpan().Fill(glowColor); - Parallel.For( + ParallelFor.WithConfiguration( minY, maxY, - configuration.ParallelOptions, + configuration, y => - { - int offsetY = y - startY; - - for (int x = minX; x < maxX; x++) { - int offsetX = x - startX; - float distance = Vector2.Distance(centre, new Vector2(offsetX, offsetY)); - Vector4 sourceColor = sourcePixels[offsetX, offsetY].ToVector4(); - TPixel packed = default(TPixel); - packed.PackFromVector4(PremultipliedLerp(sourceColor, glowColor.ToVector4(), 1 - (.95F * (distance / maxDistance)))); - sourcePixels[offsetX, offsetY] = packed; - } - }); + int offsetY = y - startY; + + for (int x = minX; x < maxX; x++) + { + int offsetX = x - startX; + float distance = Vector2.Distance(centre, new Vector2(offsetX, offsetY)); + Vector4 sourceColor = sourcePixels[offsetX, offsetY].ToVector4(); + TPixel packed = default(TPixel); + packed.PackFromVector4( + PremultipliedLerp( + sourceColor, + glowColor.ToVector4(), + 1 - (.95F * (distance / maxDistance)))); + sourcePixels[offsetX, offsetY] = packed; + } + }); } } + public static Vector4 PremultipliedLerp(Vector4 backdrop, Vector4 source, float amount) { amount = amount.Clamp(0, 1); @@ -160,4 +170,4 @@ namespace SixLabors.ImageSharp.Benchmarks } } } -} +} \ No newline at end of file diff --git a/tests/ImageSharp.Benchmarks/Samplers/Resize.cs b/tests/ImageSharp.Benchmarks/Samplers/Resize.cs index d4506fc6a9..86dc13e91e 100644 --- a/tests/ImageSharp.Benchmarks/Samplers/Resize.cs +++ b/tests/ImageSharp.Benchmarks/Samplers/Resize.cs @@ -31,7 +31,7 @@ namespace SixLabors.ImageSharp.Benchmarks [GlobalSetup] public void Setup() { - this.configuration.ParallelOptions.MaxDegreeOfParallelism = + this.configuration.MaxDegreeOfParallelism = this.EnableParallelExecution ? Environment.ProcessorCount : 1; } diff --git a/tests/ImageSharp.Sandbox46/ImageSharp.Sandbox46.csproj b/tests/ImageSharp.Sandbox46/ImageSharp.Sandbox46.csproj index 80cf162c5f..0ca3cffa18 100644 --- a/tests/ImageSharp.Sandbox46/ImageSharp.Sandbox46.csproj +++ b/tests/ImageSharp.Sandbox46/ImageSharp.Sandbox46.csproj @@ -21,7 +21,7 @@ - + diff --git a/tests/ImageSharp.Sandbox46/Program.cs b/tests/ImageSharp.Sandbox46/Program.cs index f3875e24ad..fa1d63878a 100644 --- a/tests/ImageSharp.Sandbox46/Program.cs +++ b/tests/ImageSharp.Sandbox46/Program.cs @@ -75,7 +75,7 @@ namespace SixLabors.ImageSharp.Sandbox46 foreach (object[] data in JpegProfilingBenchmarks.DecodeJpegData) { string fileName = (string)data[0]; - benchmarks.DecodeJpeg_Original(fileName); + benchmarks.DecodeJpeg(fileName); } } } diff --git a/tests/ImageSharp.Tests/Advanced/AdvancedImageExtensionsTests.cs b/tests/ImageSharp.Tests/Advanced/AdvancedImageExtensionsTests.cs index 3662666520..974099991d 100644 --- a/tests/ImageSharp.Tests/Advanced/AdvancedImageExtensionsTests.cs +++ b/tests/ImageSharp.Tests/Advanced/AdvancedImageExtensionsTests.cs @@ -59,7 +59,7 @@ namespace SixLabors.ImageSharp.Tests.Advanced Memory externalMemory = managerOfExeternalMemory.Memory; - using (Image image1 = Image.WrapMemory(externalMemory, image0.Width, image0.Height)) + using (var image1 = Image.WrapMemory(externalMemory, image0.Width, image0.Height)) { Memory internalMemory = image1.GetPixelMemory(); Assert.Equal(targetBuffer.Length, internalMemory.Length); @@ -72,7 +72,6 @@ namespace SixLabors.ImageSharp.Tests.Advanced image0.ComparePixelBufferTo(externalMemory.Span); } } - } [Theory] diff --git a/tests/ImageSharp.Tests/ConfigurationTests.cs b/tests/ImageSharp.Tests/ConfigurationTests.cs index d870b7bf78..1a7183df81 100644 --- a/tests/ImageSharp.Tests/ConfigurationTests.cs +++ b/tests/ImageSharp.Tests/ConfigurationTests.cs @@ -10,6 +10,7 @@ using SixLabors.ImageSharp.IO; using SixLabors.ImageSharp.PixelFormats; using Moq; using Xunit; +// ReSharper disable InconsistentNaming namespace SixLabors.ImageSharp.Tests { @@ -45,15 +46,6 @@ namespace SixLabors.ImageSharp.Tests Assert.True(Configuration.Default != null); } - /// - /// Test that the default configuration parallel options is not null. - /// - [Fact] - public void TestDefaultConfigurationParallelOptionsIsNotNull() - { - Assert.True(Configuration.Default.ParallelOptions != null); - } - /// /// Test that the default configuration read origin options is set to begin. /// @@ -70,9 +62,22 @@ namespace SixLabors.ImageSharp.Tests [Fact] public void TestDefaultConfigurationMaxDegreeOfParallelism() { - Assert.True(Configuration.Default.ParallelOptions.MaxDegreeOfParallelism == Environment.ProcessorCount); + Assert.True(Configuration.Default.MaxDegreeOfParallelism == Environment.ProcessorCount); + + var cfg = new Configuration(); + Assert.True(cfg.MaxDegreeOfParallelism == Environment.ProcessorCount); } + [Theory] + [InlineData(0)] + [InlineData(-42)] + public void Set_MaxDegreeOfParallelism_ToNonPositiveValue_Throws(int value) + { + var cfg = new Configuration(); + Assert.Throws(() => cfg.MaxDegreeOfParallelism = value); + } + + [Fact] public void ConstructorCallConfigureOnFormatProvider() { diff --git a/tests/ImageSharp.Tests/Drawing/BeziersTests.cs b/tests/ImageSharp.Tests/Drawing/BeziersTests.cs index 443b49c7c5..69b2098dc9 100644 --- a/tests/ImageSharp.Tests/Drawing/BeziersTests.cs +++ b/tests/ImageSharp.Tests/Drawing/BeziersTests.cs @@ -3,9 +3,10 @@ using System.Numerics; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; -using SixLabors.Memory; + using Xunit; namespace SixLabors.ImageSharp.Tests.Drawing diff --git a/tests/ImageSharp.Tests/Drawing/DrawPathTests.cs b/tests/ImageSharp.Tests/Drawing/DrawPathTests.cs index 96af63fd5d..0d791fbd23 100644 --- a/tests/ImageSharp.Tests/Drawing/DrawPathTests.cs +++ b/tests/ImageSharp.Tests/Drawing/DrawPathTests.cs @@ -2,6 +2,8 @@ // Licensed under the Apache License, Version 2.0. using System.Numerics; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; using SixLabors.Shapes; @@ -9,8 +11,6 @@ using Xunit; namespace SixLabors.ImageSharp.Tests.Drawing { - using SixLabors.Memory; - public class DrawPathTests : FileTestBase { [Fact] diff --git a/tests/ImageSharp.Tests/Drawing/FillPatternTests.cs b/tests/ImageSharp.Tests/Drawing/FillPatternTests.cs index f13f808b68..93715c586e 100644 --- a/tests/ImageSharp.Tests/Drawing/FillPatternTests.cs +++ b/tests/ImageSharp.Tests/Drawing/FillPatternTests.cs @@ -2,10 +2,12 @@ // Licensed under the Apache License, Version 2.0. using System; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Primitives; using SixLabors.ImageSharp.Processing; -using SixLabors.Memory; + using Xunit; namespace SixLabors.ImageSharp.Tests.Drawing diff --git a/tests/ImageSharp.Tests/Drawing/FillSolidBrushTests.cs b/tests/ImageSharp.Tests/Drawing/FillSolidBrushTests.cs index 1f01d54f4a..45f1340be9 100644 --- a/tests/ImageSharp.Tests/Drawing/FillSolidBrushTests.cs +++ b/tests/ImageSharp.Tests/Drawing/FillSolidBrushTests.cs @@ -81,6 +81,23 @@ namespace SixLabors.ImageSharp.Tests.Drawing provider.RunValidatingProcessorTest(c => c.Fill(color, region), testDetails, ImageComparer.Exact); } + [Theory] + [WithSolidFilledImages(16, 16, "Red", PixelTypes.Rgba32, 5, 7, 3, 8)] + [WithSolidFilledImages(16, 16, "Red", PixelTypes.Rgba32, 8, 5, 6, 4)] + public void FillRegion_WorksOnWrappedMemoryImage(TestImageProvider provider, int x0, int y0, int w, int h) + where TPixel : struct, IPixel + { + FormattableString testDetails = $"(x{x0},y{y0},w{w},h{h})"; + var region = new RectangleF(x0, y0, w, h); + TPixel color = TestUtils.GetPixelOfNamedColor("Blue"); + + provider.RunValidatingProcessorTestOnWrappedMemoryImage( + c => c.Fill(color, region), + testDetails, + ImageComparer.Exact, + useReferenceOutputFrom: nameof(this.FillRegion)); + } + public static readonly TheoryData BlendData = new TheoryData() { diff --git a/tests/ImageSharp.Tests/Drawing/LineComplexPolygonTests.cs b/tests/ImageSharp.Tests/Drawing/LineComplexPolygonTests.cs index d3b39709ae..d827975c72 100644 --- a/tests/ImageSharp.Tests/Drawing/LineComplexPolygonTests.cs +++ b/tests/ImageSharp.Tests/Drawing/LineComplexPolygonTests.cs @@ -2,6 +2,8 @@ // Licensed under the Apache License, Version 2.0. using System.Numerics; + +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; using SixLabors.Shapes; @@ -10,8 +12,6 @@ using Xunit; namespace SixLabors.ImageSharp.Tests.Drawing { - using SixLabors.Memory; - public class LineComplexPolygonTests : FileTestBase { [Fact] diff --git a/tests/ImageSharp.Tests/Drawing/LineTests.cs b/tests/ImageSharp.Tests/Drawing/LineTests.cs index 747c75cde3..43dec547eb 100644 --- a/tests/ImageSharp.Tests/Drawing/LineTests.cs +++ b/tests/ImageSharp.Tests/Drawing/LineTests.cs @@ -3,6 +3,7 @@ using System.Numerics; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; @@ -10,8 +11,6 @@ using Xunit; namespace SixLabors.ImageSharp.Tests.Drawing { - using SixLabors.Memory; - public class LineTests : FileTestBase { [Fact] diff --git a/tests/ImageSharp.Tests/Drawing/PolygonTests.cs b/tests/ImageSharp.Tests/Drawing/PolygonTests.cs index f9a41babac..6ea9c647f2 100644 --- a/tests/ImageSharp.Tests/Drawing/PolygonTests.cs +++ b/tests/ImageSharp.Tests/Drawing/PolygonTests.cs @@ -3,6 +3,7 @@ using System.Numerics; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.Primitives; using SixLabors.ImageSharp.Processing; @@ -10,8 +11,6 @@ using Xunit; namespace SixLabors.ImageSharp.Tests.Drawing { - using SixLabors.Memory; - public class PolygonTests : FileTestBase { [Fact] diff --git a/tests/ImageSharp.Tests/Drawing/SolidBezierTests.cs b/tests/ImageSharp.Tests/Drawing/SolidBezierTests.cs index 94d3d49ff5..23acc1a44f 100644 --- a/tests/ImageSharp.Tests/Drawing/SolidBezierTests.cs +++ b/tests/ImageSharp.Tests/Drawing/SolidBezierTests.cs @@ -38,6 +38,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing } } + [Theory] [WithBlankImages(500, 500, PixelTypes.Rgba32)] public void OverlayByFilledPolygonOpacity(TestImageProvider provider) diff --git a/tests/ImageSharp.Tests/Drawing/SolidComplexPolygonTests.cs b/tests/ImageSharp.Tests/Drawing/SolidComplexPolygonTests.cs index c8d3fe1bc9..2c9628e842 100644 --- a/tests/ImageSharp.Tests/Drawing/SolidComplexPolygonTests.cs +++ b/tests/ImageSharp.Tests/Drawing/SolidComplexPolygonTests.cs @@ -3,6 +3,7 @@ using System.Numerics; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; using SixLabors.Shapes; @@ -11,8 +12,6 @@ using Xunit; namespace SixLabors.ImageSharp.Tests.Drawing { - using SixLabors.Memory; - public class SolidComplexPolygonTests : FileTestBase { [Fact] diff --git a/tests/ImageSharp.Tests/Drawing/SolidPolygonTests.cs b/tests/ImageSharp.Tests/Drawing/SolidPolygonTests.cs index e42b4b481c..d7fb0a3d37 100644 --- a/tests/ImageSharp.Tests/Drawing/SolidPolygonTests.cs +++ b/tests/ImageSharp.Tests/Drawing/SolidPolygonTests.cs @@ -4,6 +4,7 @@ using System; using System.Numerics; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; using SixLabors.Shapes; @@ -12,8 +13,6 @@ using Xunit; namespace SixLabors.ImageSharp.Tests.Drawing { - using SixLabors.Memory; - public class SolidPolygonTests : FileTestBase { [Fact] @@ -184,7 +183,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing string path = TestEnvironment.CreateOutputDirectory("Drawing", "FilledPolygons"); var config = Configuration.CreateDefaultInstance(); - config.ParallelOptions.MaxDegreeOfParallelism = 1; + config.MaxDegreeOfParallelism = 1; using (var image = new Image(config, 100, 100)) { image.Mutate(x => x @@ -200,7 +199,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing string path = TestEnvironment.CreateOutputDirectory("Drawing", "FilledPolygons"); var config = Configuration.CreateDefaultInstance(); - config.ParallelOptions.MaxDegreeOfParallelism = 1; + config.MaxDegreeOfParallelism = 1; using (var image = new Image(config, 100, 100)) { image.Mutate(x => x @@ -217,7 +216,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing string path = TestEnvironment.CreateOutputDirectory("Drawing", "FilledPolygons"); var config = Configuration.CreateDefaultInstance(); - config.ParallelOptions.MaxDegreeOfParallelism = 1; + config.MaxDegreeOfParallelism = 1; using (var image = new Image(config, 200, 200)) { image.Mutate(x => x diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.CopyToBufferArea.cs b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.CopyToBufferArea.cs index 88be54dd0c..c720fdd4a7 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.CopyToBufferArea.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.CopyToBufferArea.cs @@ -5,7 +5,7 @@ //#define BENCHMARKING using SixLabors.ImageSharp.Formats.Jpeg.Components; -using SixLabors.Memory; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils; using SixLabors.Primitives; diff --git a/tests/ImageSharp.Tests/Formats/Jpg/GenericBlock8x8Tests.cs b/tests/ImageSharp.Tests/Formats/Jpg/GenericBlock8x8Tests.cs index 956ade5022..dedb094bc2 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/GenericBlock8x8Tests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/GenericBlock8x8Tests.cs @@ -4,14 +4,13 @@ using System; using SixLabors.ImageSharp.Formats.Jpeg.Components; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using Xunit; namespace SixLabors.ImageSharp.Tests.Formats.Jpg { - using SixLabors.Memory; - public class GenericBlock8x8Tests { public static Image CreateTestImage() diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs index aed650b8e9..a80312766c 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs @@ -8,7 +8,7 @@ using SixLabors.ImageSharp.ColorSpaces; using SixLabors.ImageSharp.ColorSpaces.Conversion; using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters; -using SixLabors.Memory; +using SixLabors.ImageSharp.Memory; using Xunit; using Xunit.Abstractions; @@ -290,7 +290,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg } // no need to dispose when buffer is not array owner - buffers[i] = new Buffer2D(new BasicArrayBuffer(values), values.Length, 1); + var memory = new Memory(values); + var source = new MemorySource(memory); + buffers[i] = new Buffer2D(source, values.Length, 1); } return new JpegColorConverter.ComponentValues(buffers, 0); } diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Baseline.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Baseline.cs index e266554d18..73167a4b7e 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Baseline.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Baseline.cs @@ -2,7 +2,7 @@ // Licensed under the Apache License, Version 2.0. using System; -using SixLabors.Memory; + using SixLabors.ImageSharp.PixelFormats; using Xunit; // ReSharper disable InconsistentNaming @@ -13,33 +13,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg { [Theory] [WithFileCollection(nameof(BaselineTestJpegs), PixelTypes.Rgba32)] - public void DecodeBaselineJpeg_Orig(TestImageProvider provider) - where TPixel : struct, IPixel - { - if (SkipTest(provider)) - { - return; - } - - // For 32 bit test enviroments: - provider.Configuration.MemoryAllocator = ArrayPoolMemoryAllocator.CreateWithModeratePooling(); - - using (Image image = provider.GetImage(GolangJpegDecoder)) - { - image.DebugSave(provider); - provider.Utility.TestName = DecodeBaselineJpegOutputName; - image.CompareToReferenceOutput( - this.GetImageComparer(provider), - provider, - appendPixelTypeToFileName: false); - } - - provider.Configuration.MemoryAllocator.ReleaseRetainedResources(); - } - - [Theory] - [WithFileCollection(nameof(BaselineTestJpegs), PixelTypes.Rgba32)] - public void DecodeBaselineJpeg_PdfJs(TestImageProvider provider) + public void DecodeBaselineJpeg(TestImageProvider provider) where TPixel : struct, IPixel { if (SkipTest(provider)) @@ -48,7 +22,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg return; } - using (Image image = provider.GetImage(PdfJsJpegDecoder)) + using (Image image = provider.GetImage(JpegDecoder)) { image.DebugSave(provider); @@ -62,28 +36,11 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [Theory] [WithFile(TestImages.Jpeg.Issues.CriticalEOF214, PixelTypes.Rgba32)] - public void DecodeBaselineJpeg_CriticalEOF_ShouldThrow_Golang(TestImageProvider provider) + public void DecodeBaselineJpeg_CriticalEOF_ShouldThrow(TestImageProvider provider) where TPixel : struct, IPixel { // TODO: We need a public ImageDecoderException class in ImageSharp! - Assert.ThrowsAny(() => provider.GetImage(GolangJpegDecoder)); - } - - [Theory] - [WithFile(TestImages.Jpeg.Issues.CriticalEOF214, PixelTypes.Rgba32)] - public void DecodeBaselineJpeg_CriticalEOF_ShouldThrow_PdfJs(TestImageProvider provider) - where TPixel : struct, IPixel - { - // TODO: We need a public ImageDecoderException class in ImageSharp! - Assert.ThrowsAny(() => provider.GetImage(PdfJsJpegDecoder)); - } - - [Theory(Skip = "Debug only, enable manually!")] - [WithFileCollection(nameof(BaselineTestJpegs), PixelTypes.Rgba32)] - public void CompareJpegDecoders_Baseline(TestImageProvider provider) - where TPixel : struct, IPixel - { - this.CompareJpegDecodersImpl(provider, DecodeBaselineJpegOutputName); + Assert.ThrowsAny(() => provider.GetImage(JpegDecoder)); } } } \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.MetaData.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.MetaData.cs index f217f0df14..2e67c06c18 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.MetaData.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.MetaData.cs @@ -51,7 +51,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [Theory] [MemberData(nameof(MetaDataTestData))] - public void MetaDataIsParsedCorrectly_Orig( + public void MetaDataIsParsedCorrectly( bool useIdentify, string imagePath, int expectedPixelSize, @@ -60,25 +60,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg { TestMetaDataImpl( useIdentify, - GolangJpegDecoder, - imagePath, - expectedPixelSize, - exifProfilePresent, - iccProfilePresent); - } - - [Theory] - [MemberData(nameof(MetaDataTestData))] - public void MetaDataIsParsedCorrectly_PdfJs( - bool useIdentify, - string imagePath, - int expectedPixelSize, - bool exifProfilePresent, - bool iccProfilePresent) - { - TestMetaDataImpl( - useIdentify, - PdfJsJpegDecoder, + JpegDecoder, imagePath, expectedPixelSize, exifProfilePresent, @@ -216,7 +198,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [InlineData(true)] public void Decoder_Reads_Correct_Resolution_From_Jfif(bool useIdentify) { - TestImageInfo(TestImages.Jpeg.Baseline.Floorplan, DefaultJpegDecoder, useIdentify, + TestImageInfo(TestImages.Jpeg.Baseline.Floorplan, JpegDecoder, useIdentify, imageInfo => { Assert.Equal(300, imageInfo.MetaData.HorizontalResolution); @@ -229,7 +211,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [InlineData(true)] public void Decoder_Reads_Correct_Resolution_From_Exif(bool useIdentify) { - TestImageInfo(TestImages.Jpeg.Baseline.Jpeg420Exif, DefaultJpegDecoder, useIdentify, + TestImageInfo(TestImages.Jpeg.Baseline.Jpeg420Exif, JpegDecoder, useIdentify, imageInfo => { Assert.Equal(72, imageInfo.MetaData.HorizontalResolution); diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Progressive.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Progressive.cs index c793b40341..77bc9f5404 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Progressive.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Progressive.cs @@ -1,8 +1,6 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. -using System.Linq; -using SixLabors.Memory; using SixLabors.ImageSharp.PixelFormats; using Xunit; // ReSharper disable InconsistentNaming @@ -15,7 +13,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [Theory] [WithFileCollection(nameof(ProgressiveTestJpegs), PixelTypes.Rgba32)] - public void DecodeProgressiveJpeg_Orig(TestImageProvider provider) + public void DecodeProgressiveJpeg(TestImageProvider provider) where TPixel : struct, IPixel { if (SkipTest(provider)) @@ -24,41 +22,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg return; } - // Golang decoder is unable to decode these: - if (PdfJsOnly.Any(fn => fn.Contains(provider.SourceFileOrDescription))) - { - return; - } - - // For 32 bit test enviroments: - provider.Configuration.MemoryAllocator = ArrayPoolMemoryAllocator.CreateWithModeratePooling(); - - using (Image image = provider.GetImage(GolangJpegDecoder)) - { - image.DebugSave(provider); - - provider.Utility.TestName = DecodeProgressiveJpegOutputName; - image.CompareToReferenceOutput( - this.GetImageComparer(provider), - provider, - appendPixelTypeToFileName: false); - } - - provider.Configuration.MemoryAllocator.ReleaseRetainedResources(); - } - - [Theory] - [WithFileCollection(nameof(ProgressiveTestJpegs), PixelTypes.Rgba32)] - public void DecodeProgressiveJpeg_PdfJs(TestImageProvider provider) - where TPixel : struct, IPixel - { - if (SkipTest(provider)) - { - // skipping to avoid OutOfMemoryException on CI - return; - } - - using (Image image = provider.GetImage(PdfJsJpegDecoder)) + using (Image image = provider.GetImage(JpegDecoder)) { image.DebugSave(provider); @@ -69,13 +33,5 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg appendPixelTypeToFileName: false); } } - - [Theory(Skip = "Debug only, enable manually!")] - [WithFileCollection(nameof(ProgressiveTestJpegs), PixelTypes.Rgba32)] - public void CompareJpegDecoders_Progressive(TestImageProvider provider) - where TPixel : struct, IPixel - { - this.CompareJpegDecodersImpl(provider, DecodeProgressiveJpegOutputName); - } } } \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs index 41cc6db512..4ae955c323 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs @@ -2,14 +2,10 @@ // Licensed under the Apache License, Version 2.0. using System; -using System.Collections.Generic; using System.IO; using System.Linq; -using SixLabors.ImageSharp.Formats; using SixLabors.ImageSharp.Formats.Jpeg; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; using SixLabors.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils; @@ -64,19 +60,15 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg private ITestOutputHelper Output { get; } - private static GolangJpegDecoder GolangJpegDecoder => new GolangJpegDecoder(); - - private static PdfJsJpegDecoder PdfJsJpegDecoder => new PdfJsJpegDecoder(); - - private static JpegDecoder DefaultJpegDecoder => new JpegDecoder(); + private static JpegDecoder JpegDecoder => new JpegDecoder(); [Fact] - public void ParseStream_BasicPropertiesAreCorrect1_PdfJs() + public void ParseStream_BasicPropertiesAreCorrect() { byte[] bytes = TestFile.Create(TestImages.Jpeg.Progressive.Progress).Bytes; using (var ms = new MemoryStream(bytes)) { - var decoder = new PdfJsJpegDecoderCore(Configuration.Default, new JpegDecoder()); + var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder()); decoder.ParseStream(ms); // I don't know why these numbers are different. All I know is that the decoder works @@ -89,9 +81,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg public const string DecodeBaselineJpegOutputName = "DecodeBaselineJpeg"; [Theory] - [WithFile(TestImages.Jpeg.Baseline.Calliphora, CommonNonDefaultPixelTypes, false)] - [WithFile(TestImages.Jpeg.Baseline.Calliphora, CommonNonDefaultPixelTypes, true)] - public void JpegDecoder_IsNotBoundToSinglePixelType(TestImageProvider provider, bool useOldDecoder) + [WithFile(TestImages.Jpeg.Baseline.Calliphora, CommonNonDefaultPixelTypes)] + public void JpegDecoder_IsNotBoundToSinglePixelType(TestImageProvider provider) where TPixel : struct, IPixel { if (SkipTest(provider)) @@ -102,8 +93,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg // For 32 bit test enviroments: provider.Configuration.MemoryAllocator = ArrayPoolMemoryAllocator.CreateWithModeratePooling(); - IImageDecoder decoder = useOldDecoder ? (IImageDecoder)GolangJpegDecoder : PdfJsJpegDecoder; - using (Image image = provider.GetImage(decoder)) + using (Image image = provider.GetImage(JpegDecoder)) { image.DebugSave(provider); @@ -125,34 +115,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg appendPixelTypeToFileName: false ).SingleOrDefault(); - if (report != null && report.TotalNormalizedDifference.HasValue) + if (report?.TotalNormalizedDifference != null) { return report.DifferencePercentageString; } return "0%"; } - - private void CompareJpegDecodersImpl(TestImageProvider provider, string testName) - where TPixel : struct, IPixel - { - this.Output.WriteLine(provider.SourceFileOrDescription); - provider.Utility.TestName = testName; - - using (Image image = provider.GetImage(GolangJpegDecoder)) - { - string d = this.GetDifferenceInPercentageString(image, provider); - - this.Output.WriteLine($"Difference using ORIGINAL decoder: {d}"); - } - - using (Image image = provider.GetImage(PdfJsJpegDecoder)) - { - string d = this.GetDifferenceInPercentageString(image, provider); - this.Output.WriteLine($"Difference using PDFJS decoder: {d}"); - } - } - + // DEBUG ONLY! // The PDF.js output should be saved by "tests\ImageSharp.Tests\Formats\Jpg\pdfjs\jpeg-converter.htm" // into "\tests\Images\ActualOutput\JpegDecoderTests\" @@ -175,7 +145,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg using (Image expectedImage = provider.GetReferenceOutputImage(appendPixelTypeToFileName: false)) using (var pdfJsOriginalResult = Image.Load(pdfJsOriginalResultPath)) - using (var pdfJsPortResult = Image.Load(sourceBytes, PdfJsJpegDecoder)) + using (var pdfJsPortResult = Image.Load(sourceBytes, JpegDecoder)) { ImageSimilarityReport originalReport = comparer.CompareImagesOrFrames(expectedImage, pdfJsOriginalResult); ImageSimilarityReport portReport = comparer.CompareImagesOrFrames(expectedImage, pdfJsPortResult); diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegFileMarkerTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegFileMarkerTests.cs new file mode 100644 index 0000000000..42eea2708b --- /dev/null +++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegFileMarkerTests.cs @@ -0,0 +1,25 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using SixLabors.ImageSharp.Formats.Jpeg; +using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.Formats.Jpg +{ + public class JpegFileMarkerTests + { + [Fact] + public void MarkerConstructorAssignsProperties() + { + const byte app1 = JpegConstants.Markers.APP1; + const int position = 5; + var marker = new JpegFileMarker(app1, position); + + Assert.Equal(app1, marker.Marker); + Assert.Equal(position, marker.Position); + Assert.False(marker.Invalid); + Assert.Equal(app1.ToString("X"), marker.ToString()); + } + } +} diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegImagePostProcessorTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegImagePostProcessorTests.cs index 843843f797..cfa421a82b 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/JpegImagePostProcessorTests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegImagePostProcessorTests.cs @@ -1,9 +1,8 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. +using SixLabors.ImageSharp.Formats.Jpeg; using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils; using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison; @@ -48,7 +47,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg where TPixel : struct, IPixel { string imageFile = provider.SourceFileOrDescription; - using (PdfJsJpegDecoderCore decoder = JpegFixture.ParsePdfJsStream(imageFile)) + using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile)) using (var pp = new JpegImagePostProcessor(Configuration.Default.MemoryAllocator, decoder)) using (var imageFrame = new ImageFrame(Configuration.Default, decoder.ImageWidth, decoder.ImageHeight)) { @@ -68,7 +67,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg where TPixel : struct, IPixel { string imageFile = provider.SourceFileOrDescription; - using (PdfJsJpegDecoderCore decoder = JpegFixture.ParsePdfJsStream(imageFile)) + using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile)) using (var pp = new JpegImagePostProcessor(Configuration.Default.MemoryAllocator, decoder)) using (var image = new Image(decoder.ImageWidth, decoder.ImageHeight)) { diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegProfilingBenchmarks.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegProfilingBenchmarks.cs index b0f342f5ab..32538090dc 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/JpegProfilingBenchmarks.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegProfilingBenchmarks.cs @@ -8,8 +8,6 @@ using System.Numerics; using SixLabors.ImageSharp.Formats; using SixLabors.ImageSharp.Formats.Jpeg; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; using SixLabors.ImageSharp.PixelFormats; using Xunit; @@ -34,18 +32,11 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg TestImages.Jpeg.Baseline.Jpeg444, }; - //[Theory] // Benchmark, enable manually - //[MemberData(nameof(DecodeJpegData))] - public void DecodeJpeg_Original(string fileName) - { - this.DecodeJpegBenchmarkImpl(fileName, new GolangJpegDecoder()); - } - // [Theory] // Benchmark, enable manually // [MemberData(nameof(DecodeJpegData))] - public void DecodeJpeg_PdfJs(string fileName) + public void DecodeJpeg(string fileName) { - this.DecodeJpegBenchmarkImpl(fileName, new PdfJsJpegDecoder()); + this.DecodeJpegBenchmarkImpl(fileName, new JpegDecoder()); } private void DecodeJpegBenchmarkImpl(string fileName, IImageDecoder decoder) @@ -70,7 +61,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg ExecutionCount, () => { - Image img = Image.Load(bytes, decoder); + var img = Image.Load(bytes, decoder); }, // ReSharper disable once ExplicitCallerInfoArgument $"Decode {fileName}"); diff --git a/tests/ImageSharp.Tests/Formats/Jpg/ParseStreamTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/ParseStreamTests.cs index 827a459cde..3657110c6c 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/ParseStreamTests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/ParseStreamTests.cs @@ -2,12 +2,10 @@ // Licensed under the Apache License, Version 2.0. using System.Text; + +using SixLabors.ImageSharp.Formats.Jpeg; using SixLabors.ImageSharp.Formats.Jpeg.Components; using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components; using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils; using SixLabors.Primitives; @@ -30,53 +28,20 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [InlineData(TestImages.Jpeg.Baseline.Jpeg400, JpegColorSpace.Grayscale)] [InlineData(TestImages.Jpeg.Baseline.Ycck, JpegColorSpace.Ycck)] [InlineData(TestImages.Jpeg.Baseline.Cmyk, JpegColorSpace.Cmyk)] - public void ColorSpace_IsDeducedCorrectlyGolang(string imageFile, object expectedColorSpaceValue) + public void ColorSpace_IsDeducedCorrectly(string imageFile, object expectedColorSpaceValue) { var expecteColorSpace = (JpegColorSpace)expectedColorSpaceValue; - using (GolangJpegDecoderCore decoder = JpegFixture.ParseGolangStream(imageFile)) + using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile)) { Assert.Equal(expecteColorSpace, decoder.ColorSpace); } } - [Theory] - [InlineData(TestImages.Jpeg.Baseline.Testorig420, JpegColorSpace.YCbCr)] - [InlineData(TestImages.Jpeg.Baseline.Jpeg400, JpegColorSpace.Grayscale)] - [InlineData(TestImages.Jpeg.Baseline.Ycck, JpegColorSpace.Ycck)] - [InlineData(TestImages.Jpeg.Baseline.Cmyk, JpegColorSpace.Cmyk)] - public void ColorSpace_IsDeducedCorrectlyPdfJs(string imageFile, object expectedColorSpaceValue) - { - var expecteColorSpace = (JpegColorSpace)expectedColorSpaceValue; - - using (PdfJsJpegDecoderCore decoder = JpegFixture.ParsePdfJsStream(imageFile)) - { - Assert.Equal(expecteColorSpace, decoder.ColorSpace); - } - } - - [Fact] - public void ComponentScalingIsCorrect_1ChannelJpegGolang() - { - using (GolangJpegDecoderCore decoder = JpegFixture.ParseGolangStream(TestImages.Jpeg.Baseline.Jpeg400)) - { - Assert.Equal(1, decoder.ComponentCount); - Assert.Equal(1, decoder.Components.Length); - - Size expectedSizeInBlocks = decoder.ImageSizeInPixels.DivideRoundUp(8); - - Assert.Equal(expectedSizeInBlocks, decoder.ImageSizeInMCU); - - var uniform1 = new Size(1, 1); - GolangComponent c0 = decoder.Components[0]; - VerifyJpeg.VerifyComponent(c0, expectedSizeInBlocks, uniform1, uniform1); - } - } - [Fact] - public void ComponentScalingIsCorrect_1ChannelJpegPdfJs() + public void ComponentScalingIsCorrect_1ChannelJpeg() { - using (PdfJsJpegDecoderCore decoder = JpegFixture.ParsePdfJsStream(TestImages.Jpeg.Baseline.Jpeg400)) + using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(TestImages.Jpeg.Baseline.Jpeg400)) { Assert.Equal(1, decoder.ComponentCount); Assert.Equal(1, decoder.Components.Length); @@ -86,7 +51,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg Assert.Equal(expectedSizeInBlocks, decoder.ImageSizeInMCU); var uniform1 = new Size(1, 1); - PdfJsFrameComponent c0 = decoder.Components[0]; + JpegComponent c0 = decoder.Components[0]; VerifyJpeg.VerifyComponent(c0, expectedSizeInBlocks, uniform1, uniform1); } } @@ -98,40 +63,16 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [InlineData(TestImages.Jpeg.Baseline.Testorig420)] [InlineData(TestImages.Jpeg.Baseline.Ycck)] [InlineData(TestImages.Jpeg.Baseline.Cmyk)] - public void PrintComponentDataGolang(string imageFile) - { - var sb = new StringBuilder(); - - using (GolangJpegDecoderCore decoder = JpegFixture.ParseGolangStream(imageFile)) - { - sb.AppendLine(imageFile); - sb.AppendLine($"Size:{decoder.ImageSizeInPixels} MCU:{decoder.ImageSizeInMCU}"); - GolangComponent c0 = decoder.Components[0]; - GolangComponent c1 = decoder.Components[1]; - - sb.AppendLine($"Luma: SAMP: {c0.SamplingFactors} BLOCKS: {c0.SizeInBlocks}"); - sb.AppendLine($"Chroma: {c1.SamplingFactors} BLOCKS: {c1.SizeInBlocks}"); - } - this.Output.WriteLine(sb.ToString()); - } - - [Theory] - [InlineData(TestImages.Jpeg.Baseline.Jpeg444)] - [InlineData(TestImages.Jpeg.Baseline.Jpeg420Exif)] - [InlineData(TestImages.Jpeg.Baseline.Jpeg420Small)] - [InlineData(TestImages.Jpeg.Baseline.Testorig420)] - [InlineData(TestImages.Jpeg.Baseline.Ycck)] - [InlineData(TestImages.Jpeg.Baseline.Cmyk)] - public void PrintComponentDataPdfJs(string imageFile) + public void PrintComponentData(string imageFile) { var sb = new StringBuilder(); - using (PdfJsJpegDecoderCore decoder = JpegFixture.ParsePdfJsStream(imageFile)) + using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile)) { sb.AppendLine(imageFile); sb.AppendLine($"Size:{decoder.ImageSizeInPixels} MCU:{decoder.ImageSizeInMCU}"); - PdfJsFrameComponent c0 = decoder.Components[0]; - PdfJsFrameComponent c1 = decoder.Components[1]; + JpegComponent c0 = decoder.Components[0]; + JpegComponent c1 = decoder.Components[1]; sb.AppendLine($"Luma: SAMP: {c0.SamplingFactors} BLOCKS: {c0.SizeInBlocks}"); sb.AppendLine($"Chroma: {c1.SamplingFactors} BLOCKS: {c1.SizeInBlocks}"); @@ -152,48 +93,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [Theory] [MemberData(nameof(ComponentVerificationData))] - public void ComponentScalingIsCorrect_MultiChannelJpegGolang( - string imageFile, - int componentCount, - object expectedLumaFactors, - object expectedChromaFactors) - { - var fLuma = (Size)expectedLumaFactors; - var fChroma = (Size)expectedChromaFactors; - - using (GolangJpegDecoderCore decoder = JpegFixture.ParseGolangStream(imageFile)) - { - Assert.Equal(componentCount, decoder.ComponentCount); - Assert.Equal(componentCount, decoder.Components.Length); - - GolangComponent c0 = decoder.Components[0]; - GolangComponent c1 = decoder.Components[1]; - GolangComponent c2 = decoder.Components[2]; - - var uniform1 = new Size(1, 1); - - Size expectedLumaSizeInBlocks = decoder.ImageSizeInMCU.MultiplyBy(fLuma); - - Size divisor = fLuma.DivideBy(fChroma); - - Size expectedChromaSizeInBlocks = expectedLumaSizeInBlocks.DivideRoundUp(divisor); - - VerifyJpeg.VerifyComponent(c0, expectedLumaSizeInBlocks, fLuma, uniform1); - VerifyJpeg.VerifyComponent(c1, expectedChromaSizeInBlocks, fChroma, divisor); - VerifyJpeg.VerifyComponent(c2, expectedChromaSizeInBlocks, fChroma, divisor); - - if (componentCount == 4) - { - GolangComponent c3 = decoder.Components[2]; - VerifyJpeg.VerifyComponent(c3, expectedLumaSizeInBlocks, fLuma, uniform1); - } - } - } - - - [Theory] - [MemberData(nameof(ComponentVerificationData))] - public void ComponentScalingIsCorrect_MultiChannelJpegPdfJs( + public void ComponentScalingIsCorrect_MultiChannelJpeg( string imageFile, int componentCount, object expectedLumaFactors, @@ -202,14 +102,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg var fLuma = (Size)expectedLumaFactors; var fChroma = (Size)expectedChromaFactors; - using (PdfJsJpegDecoderCore decoder = JpegFixture.ParsePdfJsStream(imageFile)) + using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile)) { Assert.Equal(componentCount, decoder.ComponentCount); Assert.Equal(componentCount, decoder.Components.Length); - PdfJsFrameComponent c0 = decoder.Components[0]; - PdfJsFrameComponent c1 = decoder.Components[1]; - PdfJsFrameComponent c2 = decoder.Components[2]; + JpegComponent c0 = decoder.Components[0]; + JpegComponent c1 = decoder.Components[1]; + JpegComponent c2 = decoder.Components[2]; var uniform1 = new Size(1, 1); @@ -225,7 +125,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg if (componentCount == 4) { - PdfJsFrameComponent c3 = decoder.Components[2]; + JpegComponent c3 = decoder.Components[2]; VerifyJpeg.VerifyComponent(c3, expectedLumaSizeInBlocks, fLuma, uniform1); } } diff --git a/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs index 46a688b49c..d5a1fb7ba0 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs @@ -4,8 +4,6 @@ using System.IO; using System.Linq; using SixLabors.ImageSharp.Formats.Jpeg; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils; @@ -42,10 +40,10 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [Theory(Skip = "Debug only, enable manually!")] [WithFileCollection(nameof(AllTestJpegs), PixelTypes.Rgba32)] - public void PdfJsDecoder_ParseStream_SaveSpectralResult(TestImageProvider provider) + public void Decoder_ParseStream_SaveSpectralResult(TestImageProvider provider) where TPixel : struct, IPixel { - var decoder = new PdfJsJpegDecoderCore(Configuration.Default, new JpegDecoder()); + var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder()); byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes; @@ -58,25 +56,30 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg } } - [Theory(Skip = "Debug only, enable manually!")] + [Theory] [WithFileCollection(nameof(AllTestJpegs), PixelTypes.Rgba32)] - public void OriginalDecoder_ParseStream_SaveSpectralResult(TestImageProvider provider) + public void VerifySpectralCorrectness(TestImageProvider provider) where TPixel : struct, IPixel { - var decoder = new GolangJpegDecoderCore(Configuration.Default, new JpegDecoder()); + if (!TestEnvironment.IsWindows) + { + return; + } + + var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder()); byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes; using (var ms = new MemoryStream(sourceBytes)) { - decoder.ParseStream(ms, false); + decoder.ParseStream(ms); + var imageSharpData = LibJpegTools.SpectralData.LoadFromImageSharpDecoder(decoder); - var data = LibJpegTools.SpectralData.LoadFromImageSharpDecoder(decoder); - VerifyJpeg.SaveSpectralImage(provider, data); + this.VerifySpectralCorrectnessImpl(provider, imageSharpData); } } - - private void VerifySpectralCorrectness( + + private void VerifySpectralCorrectnessImpl( TestImageProvider provider, LibJpegTools.SpectralData imageSharpData) where TPixel : struct, IPixel @@ -107,7 +110,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg this.Output.WriteLine($"Component{i}: {diff}"); averageDifference += diff.average; totalDifference += diff.total; - tolerance += libJpegComponent.SpectralBlocks.Buffer.GetSpan().Length; + tolerance += libJpegComponent.SpectralBlocks.MemorySource.GetSpan().Length; } averageDifference /= componentCount; @@ -119,51 +122,5 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg Assert.True(totalDifference < tolerance); } - - [Theory] - [WithFileCollection(nameof(AllTestJpegs), PixelTypes.Rgba32)] - public void VerifySpectralCorrectness_PdfJs(TestImageProvider provider) - where TPixel : struct, IPixel - { - if (!TestEnvironment.IsWindows) - { - return; - } - - var decoder = new PdfJsJpegDecoderCore(Configuration.Default, new JpegDecoder()); - - byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes; - - using (var ms = new MemoryStream(sourceBytes)) - { - decoder.ParseStream(ms); - var imageSharpData = LibJpegTools.SpectralData.LoadFromImageSharpDecoder(decoder); - - this.VerifySpectralCorrectness(provider, imageSharpData); - } - } - - [Theory] - [WithFileCollection(nameof(AllTestJpegs), PixelTypes.Rgba32)] - public void VerifySpectralCorrectness_Golang(TestImageProvider provider) - where TPixel : struct, IPixel - { - if (!TestEnvironment.IsWindows) - { - return; - } - - var decoder = new GolangJpegDecoderCore(Configuration.Default, new GolangJpegDecoder()); - - byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes; - - using (var ms = new MemoryStream(sourceBytes)) - { - decoder.ParseStream(ms); - var imageSharpData = LibJpegTools.SpectralData.LoadFromImageSharpDecoder(decoder); - - this.VerifySpectralCorrectness(provider, imageSharpData); - } - } } } \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/JpegFixture.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/JpegFixture.cs index 7fe98e2af7..d14fbc3fc3 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/JpegFixture.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/JpegFixture.cs @@ -10,8 +10,6 @@ using System.Text; using SixLabors.ImageSharp.Formats.Jpeg; using SixLabors.ImageSharp.Formats.Jpeg.Components; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; using Xunit; using Xunit.Abstractions; @@ -175,23 +173,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils Assert.False(failed); } - internal static GolangJpegDecoderCore ParseGolangStream(string testFileName, bool metaDataOnly = false) + internal static JpegDecoderCore ParseJpegStream(string testFileName, bool metaDataOnly = false) { byte[] bytes = TestFile.Create(testFileName).Bytes; using (var ms = new MemoryStream(bytes)) { - var decoder = new GolangJpegDecoderCore(Configuration.Default, new JpegDecoder()); - decoder.ParseStream(ms, metaDataOnly); - return decoder; - } - } - - internal static PdfJsJpegDecoderCore ParsePdfJsStream(string testFileName, bool metaDataOnly = false) - { - byte[] bytes = TestFile.Create(testFileName).Bytes; - using (var ms = new MemoryStream(bytes)) - { - var decoder = new PdfJsJpegDecoderCore(Configuration.Default, new JpegDecoder()); + var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder()); decoder.ParseStream(ms, metaDataOnly); return decoder; } diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs index 645ee45128..57d92fa151 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs @@ -1,18 +1,18 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System; +using System.Linq; +using System.Numerics; + using SixLabors.ImageSharp.Formats.Jpeg.Components; using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; +using SixLabors.Primitives; namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils { - using System; - using System.Linq; - using System.Numerics; - - using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder; - using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components; - using SixLabors.Memory; - using SixLabors.Primitives; - internal static partial class LibJpegTools { /// @@ -57,7 +57,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils this.SpectralBlocks[x, y] = new Block8x8(data); } - public static ComponentData Load(PdfJsFrameComponent c, int index) + public static ComponentData Load(JpegComponent c, int index) { var result = new ComponentData( c.WidthInBlocks, @@ -77,26 +77,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils return result; } - public static ComponentData Load(GolangComponent c) - { - var result = new ComponentData( - c.SizeInBlocks.Width, - c.SizeInBlocks.Height, - c.Index - ); - - for (int y = 0; y < result.HeightInBlocks; y++) - { - for (int x = 0; x < result.WidthInBlocks; x++) - { - short[] data = c.GetBlockReference(x, y).ToArray(); - result.MakeBlock(data, y, x); - } - } - - return result; - } - public Image CreateGrayScaleImage() { var result = new Image(this.WidthInBlocks * 8, this.HeightInBlocks * 8); @@ -143,8 +123,16 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils public bool Equals(ComponentData other) { - if (object.ReferenceEquals(null, other)) return false; - if (object.ReferenceEquals(this, other)) return true; + if (other is null) + { + return false; + } + + if (ReferenceEquals(this, other)) + { + return true; + } + bool ok = this.Index == other.Index && this.HeightInBlocks == other.HeightInBlocks && this.WidthInBlocks == other.WidthInBlocks; //&& this.MinVal == other.MinVal @@ -165,8 +153,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils public override bool Equals(object obj) { - if (Object.ReferenceEquals(null, obj)) return false; - if (Object.ReferenceEquals(this, obj)) return true; + if (obj is null) return false; + if (object.ReferenceEquals(this, obj)) return true; if (obj.GetType() != this.GetType()) return false; return this.Equals((ComponentData)obj); } @@ -175,7 +163,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils { unchecked { - var hashCode = this.Index; + int hashCode = this.Index; hashCode = (hashCode * 397) ^ this.HeightInBlocks; hashCode = (hashCode * 397) ^ this.WidthInBlocks; hashCode = (hashCode * 397) ^ this.MinVal.GetHashCode(); diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs index ae8194e1a9..bcfabca390 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs @@ -5,11 +5,9 @@ using System; using System.Linq; using System.Numerics; +using SixLabors.ImageSharp.Formats.Jpeg; using SixLabors.ImageSharp.Formats.Jpeg.Components; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; -using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components; +using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; using SixLabors.ImageSharp.PixelFormats; namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils @@ -32,17 +30,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils this.Components = components; } - public static SpectralData LoadFromImageSharpDecoder(PdfJsJpegDecoderCore decoder) + public static SpectralData LoadFromImageSharpDecoder(JpegDecoderCore decoder) { - PdfJsFrameComponent[] srcComponents = decoder.Frame.Components; - LibJpegTools.ComponentData[] destComponents = srcComponents.Select(LibJpegTools.ComponentData.Load).ToArray(); - - return new SpectralData(destComponents); - } - - public static SpectralData LoadFromImageSharpDecoder(GolangJpegDecoderCore decoder) - { - GolangComponent[] srcComponents = decoder.Components; + JpegComponent[] srcComponents = decoder.Frame.Components; LibJpegTools.ComponentData[] destComponents = srcComponents.Select(LibJpegTools.ComponentData.Load).ToArray(); return new SpectralData(destComponents); @@ -108,8 +98,16 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils public bool Equals(SpectralData other) { - if (object.ReferenceEquals(null, other)) return false; - if (object.ReferenceEquals(this, other)) return true; + if (other is null) + { + return false; + } + + if (ReferenceEquals(this, other)) + { + return true; + } + if (this.ComponentCount != other.ComponentCount) { return false; diff --git a/tests/ImageSharp.Tests/Formats/Png/PngChunkTypeTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngChunkTypeTests.cs index 016c932dd1..35652dd6b5 100644 --- a/tests/ImageSharp.Tests/Formats/Png/PngChunkTypeTests.cs +++ b/tests/ImageSharp.Tests/Formats/Png/PngChunkTypeTests.cs @@ -19,6 +19,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Png Assert.Equal(PngChunkType.Text, GetType("tEXt")); Assert.Equal(PngChunkType.Gamma, GetType("gAMA")); Assert.Equal(PngChunkType.Physical, GetType("pHYs")); + Assert.Equal(PngChunkType.Exif, GetType("eXIf")); } private static PngChunkType GetType(string text) diff --git a/tests/ImageSharp.Tests/Formats/Jpg/DoubleBufferedStreamReaderTests.cs b/tests/ImageSharp.Tests/IO/DoubleBufferedStreamReaderTests.cs similarity index 87% rename from tests/ImageSharp.Tests/Formats/Jpg/DoubleBufferedStreamReaderTests.cs rename to tests/ImageSharp.Tests/IO/DoubleBufferedStreamReaderTests.cs index 20b199441c..4fac8d9546 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/DoubleBufferedStreamReaderTests.cs +++ b/tests/ImageSharp.Tests/IO/DoubleBufferedStreamReaderTests.cs @@ -3,11 +3,11 @@ using System; using System.IO; -using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components; +using SixLabors.ImageSharp.IO; using SixLabors.Memory; using Xunit; -namespace SixLabors.ImageSharp.Tests.Formats.Jpg +namespace SixLabors.ImageSharp.Tests.IO { public class DoubleBufferedStreamReaderTests { @@ -29,6 +29,24 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg } } + [Fact] + public void DoubleBufferedStreamReaderCanReadSingleByteFromOffset() + { + using (MemoryStream stream = this.CreateTestStream()) + { + byte[] expected = stream.ToArray(); + const int offset = 5; + var reader = new DoubleBufferedStreamReader(this.allocator, stream); + reader.Position = offset; + + Assert.Equal(expected[offset], reader.ReadByte()); + + // We've read a whole chunk but increment by 1 in our reader. + Assert.Equal(stream.Position, DoubleBufferedStreamReader.ChunkLength + offset); + Assert.Equal(offset + 1, reader.Position); + } + } + [Fact] public void DoubleBufferedStreamReaderCanReadSubsequentSingleByteCorrectly() { @@ -138,7 +156,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg // Skip Again reader.Skip(skip2); - // First Skap + First Read + Second Skip + // First Skip + First Read + Second Skip int position = skip + plusOne + skip2; Assert.Equal(position, reader.Position); diff --git a/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs b/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs index 066be4a737..69572425c9 100644 --- a/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs +++ b/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs @@ -2,7 +2,17 @@ // Licensed under the Apache License, Version 2.0. using System; -using SixLabors.Memory; +using System.Buffers; +using System.Drawing; +using System.Drawing.Imaging; +using System.Runtime.CompilerServices; + +using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Common.Helpers; +using SixLabors.ImageSharp.MetaData; +using SixLabors.ImageSharp.PixelFormats; +using SixLabors.Shapes; +using SixLabors.ImageSharp.Processing; using Xunit; // ReSharper disable InconsistentNaming @@ -12,13 +22,149 @@ namespace SixLabors.ImageSharp.Tests { public class WrapMemory { + /// + /// A exposing the locked pixel memory of a instance. + /// TODO: This should be an example in https://github.com/SixLabors/Samples + /// + class BitmapMemoryManager : MemoryManager + { + private readonly Bitmap bitmap; + + private readonly BitmapData bmpData; + + private readonly int length; + + public BitmapMemoryManager(Bitmap bitmap) + { + if (bitmap.PixelFormat != PixelFormat.Format32bppArgb) + { + throw new ArgumentException("bitmap.PixelFormat != PixelFormat.Format32bppArgb", nameof(bitmap)); + } + + this.bitmap = bitmap; + var rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height); + this.bmpData = bitmap.LockBits(rectangle, ImageLockMode.ReadWrite, bitmap.PixelFormat); + this.length = bitmap.Width * bitmap.Height; + } + + public bool IsDisposed { get; private set; } + + protected override void Dispose(bool disposing) + { + if (this.IsDisposed) + { + return; + } + + if (disposing) + { + this.bitmap.UnlockBits(this.bmpData); + } + + this.IsDisposed = true; + } + + public override unsafe Span GetSpan() + { + void* ptr = (void*) this.bmpData.Scan0; + return new Span(ptr, this.length); + } + + public override unsafe MemoryHandle Pin(int elementIndex = 0) + { + void* ptr = (void*)this.bmpData.Scan0; + return new MemoryHandle(ptr); + } + + public override void Unpin() + { + } + } + + [Fact] + public void WrapMemory_CreatedImageIsCorrect() + { + Configuration cfg = Configuration.Default.ShallowCopy(); + var metaData = new ImageMetaData(); + + var array = new Rgba32[25]; + var memory = new Memory(array); + + using (var image = Image.WrapMemory(cfg, memory, 5, 5, metaData)) + { + ref Rgba32 pixel0 = ref image.GetPixelSpan()[0]; + Assert.True(Unsafe.AreSame(ref array[0], ref pixel0)); + + Assert.Equal(cfg, image.GetConfiguration()); + Assert.Equal(metaData, image.MetaData); + } + } + + [Fact] + public void WrapSystemDrawingBitmap_WhenObserved() + { + if (ShouldSkipBitmapTest) + { + return; + } + + using (var bmp = new Bitmap(51, 23)) + { + using (var memoryManager = new BitmapMemoryManager(bmp)) + { + Memory memory = memoryManager.Memory; + Bgra32 bg = NamedColors.Red; + Bgra32 fg = NamedColors.Green; + + using (var image = Image.WrapMemory(memory, bmp.Width, bmp.Height)) + { + Assert.Equal(memory, image.GetPixelMemory()); + image.Mutate(c => c.Fill(bg).Fill(fg, new RectangularPolygon(10, 10, 10, 10))); + } + + Assert.False(memoryManager.IsDisposed); + } + + string fn = System.IO.Path.Combine( + TestEnvironment.ActualOutputDirectoryFullPath, + $"{nameof(this.WrapSystemDrawingBitmap_WhenObserved)}.bmp"); + + bmp.Save(fn, ImageFormat.Bmp); + } + } + [Fact] - public void ConsumedBuffer_IsMemoryOwner_ReturnsFalse() + public void WrapSystemDrawingBitmap_WhenOwned() { - var memory = new Memory(new int[55]); - var buffer = new ConsumedBuffer(memory); - Assert.False(buffer.IsMemoryOwner); + if (ShouldSkipBitmapTest) + { + return; + } + + using (var bmp = new Bitmap(51, 23)) + { + var memoryManager = new BitmapMemoryManager(bmp); + Bgra32 bg = NamedColors.Red; + Bgra32 fg = NamedColors.Green; + + using (var image = Image.WrapMemory(memoryManager, bmp.Width, bmp.Height)) + { + Assert.Equal(memoryManager.Memory, image.GetPixelMemory()); + image.Mutate(c => c.Fill(bg).Fill(fg, new RectangularPolygon(10, 10, 10, 10))); + } + + Assert.True(memoryManager.IsDisposed); + + string fn = System.IO.Path.Combine( + TestEnvironment.ActualOutputDirectoryFullPath, + $"{nameof(this.WrapSystemDrawingBitmap_WhenOwned)}.bmp"); + + bmp.Save(fn, ImageFormat.Bmp); + } } + + private static bool ShouldSkipBitmapTest => + !TestEnvironment.Is64BitProcess || TestHelpers.ImageSharpBuiltAgainst != "netcoreapp2.1"; } } } \ No newline at end of file diff --git a/tests/ImageSharp.Tests/ImageSharp.Tests.csproj b/tests/ImageSharp.Tests/ImageSharp.Tests.csproj index 9e15b6abad..d153ecf50f 100644 --- a/tests/ImageSharp.Tests/ImageSharp.Tests.csproj +++ b/tests/ImageSharp.Tests/ImageSharp.Tests.csproj @@ -36,7 +36,7 @@ - + diff --git a/tests/ImageSharp.Tests/Memory/ArrayPoolMemoryManagerTests.cs b/tests/ImageSharp.Tests/Memory/ArrayPoolMemoryManagerTests.cs deleted file mode 100644 index c8e304b41a..0000000000 --- a/tests/ImageSharp.Tests/Memory/ArrayPoolMemoryManagerTests.cs +++ /dev/null @@ -1,237 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -// ReSharper disable InconsistentNaming - -using SixLabors.ImageSharp.PixelFormats; - -namespace SixLabors.ImageSharp.Tests.Memory -{ - using System; - using System.Linq; - using System.Runtime.CompilerServices; - using System.Runtime.InteropServices; - - using SixLabors.Memory; - - using Xunit; - - public class ArrayPoolMemoryManagerTests - { - private const int MaxPooledBufferSizeInBytes = 2048; - - private const int PoolSelectorThresholdInBytes = MaxPooledBufferSizeInBytes / 2; - - private MemoryAllocator MemoryAllocator { get; set; } = new ArrayPoolMemoryAllocator(MaxPooledBufferSizeInBytes, PoolSelectorThresholdInBytes); - - /// - /// Rent a buffer -> return it -> re-rent -> verify if it's span points to the previous location - /// - private bool CheckIsRentingPooledBuffer(int length) - where T : struct - { - IBuffer buffer = this.MemoryAllocator.Allocate(length); - ref T ptrToPrevPosition0 = ref buffer.GetReference(); - buffer.Dispose(); - - buffer = this.MemoryAllocator.Allocate(length); - bool sameBuffers = Unsafe.AreSame(ref ptrToPrevPosition0, ref buffer.GetReference()); - buffer.Dispose(); - - return sameBuffers; - } - - public class BufferTests : BufferTestSuite - { - public BufferTests() - : base(new ArrayPoolMemoryAllocator(MaxPooledBufferSizeInBytes, PoolSelectorThresholdInBytes)) - { - } - } - - public class Constructor - { - [Fact] - public void WhenBothParametersPassedByUser() - { - var mgr = new ArrayPoolMemoryAllocator(1111, 666); - Assert.Equal(1111, mgr.MaxPoolSizeInBytes); - Assert.Equal(666, mgr.PoolSelectorThresholdInBytes); - } - - [Fact] - public void WhenPassedOnly_MaxPooledBufferSizeInBytes_SmallerThresholdValueIsAutoCalculated() - { - var mgr = new ArrayPoolMemoryAllocator(5000); - Assert.Equal(5000, mgr.MaxPoolSizeInBytes); - Assert.True(mgr.PoolSelectorThresholdInBytes < mgr.MaxPoolSizeInBytes); - } - - [Fact] - public void When_PoolSelectorThresholdInBytes_IsGreaterThan_MaxPooledBufferSizeInBytes_ExceptionIsThrown() - { - Assert.ThrowsAny(() => { new ArrayPoolMemoryAllocator(100, 200); }); - } - } - - [StructLayout(LayoutKind.Explicit, Size = MaxPooledBufferSizeInBytes / 5)] - struct LargeStruct - { - } - - [Theory] - [InlineData(32)] - [InlineData(512)] - [InlineData(MaxPooledBufferSizeInBytes - 1)] - public void SmallBuffersArePooled_OfByte(int size) - { - Assert.True(this.CheckIsRentingPooledBuffer(size)); - } - - - [Theory] - [InlineData(128 * 1024 * 1024)] - [InlineData(MaxPooledBufferSizeInBytes + 1)] - public void LargeBuffersAreNotPooled_OfByte(int size) - { - if (!TestEnvironment.Is64BitProcess) - { - // can lead to OutOfMemoryException - return; - } - - Assert.False(this.CheckIsRentingPooledBuffer(size)); - } - - [Fact] - public unsafe void SmallBuffersArePooled_OfBigValueType() - { - int count = MaxPooledBufferSizeInBytes / sizeof(LargeStruct) - 1; - - Assert.True(this.CheckIsRentingPooledBuffer(count)); - } - - [Fact] - public unsafe void LaregeBuffersAreNotPooled_OfBigValueType() - { - if (!TestEnvironment.Is64BitProcess) - { - // can lead to OutOfMemoryException - return; - } - - int count = MaxPooledBufferSizeInBytes / sizeof(LargeStruct) + 1; - - Assert.False(this.CheckIsRentingPooledBuffer(count)); - } - - [Theory] - [InlineData(false)] - [InlineData(true)] - public void CleaningRequests_AreControlledByAllocationParameter_Clean(bool clean) - { - using (IBuffer firstAlloc = this.MemoryAllocator.Allocate(42)) - { - firstAlloc.GetSpan().Fill(666); - } - - using (IBuffer secondAlloc = this.MemoryAllocator.Allocate(42, clean)) - { - int expected = clean ? 0 : 666; - Assert.Equal(expected, secondAlloc.GetSpan()[0]); - } - } - - [Theory] - [InlineData(false)] - [InlineData(true)] - public void ReleaseRetainedResources_ReplacesInnerArrayPool(bool keepBufferAlive) - { - IBuffer buffer = this.MemoryAllocator.Allocate(32); - ref int ptrToPrev0 = ref MemoryMarshal.GetReference(buffer.GetSpan()); - - if (!keepBufferAlive) - { - buffer.Dispose(); - } - - this.MemoryAllocator.ReleaseRetainedResources(); - - buffer = this.MemoryAllocator.Allocate(32); - - Assert.False(Unsafe.AreSame(ref ptrToPrev0, ref buffer.GetReference())); - } - - [Fact] - public void ReleaseRetainedResources_DisposingPreviouslyAllocatedBuffer_IsAllowed() - { - IBuffer buffer = this.MemoryAllocator.Allocate(32); - this.MemoryAllocator.ReleaseRetainedResources(); - buffer.Dispose(); - } - - [Fact] - public void AllocationOverLargeArrayThreshold_UsesDifferentPool() - { - if (!TestEnvironment.Is64BitProcess) - { - // can lead to OutOfMemoryException - return; - } - - int arrayLengthThreshold = PoolSelectorThresholdInBytes / sizeof(int); - - IBuffer small = this.MemoryAllocator.Allocate(arrayLengthThreshold - 1); - ref int ptr2Small = ref small.GetReference(); - small.Dispose(); - - IBuffer large = this.MemoryAllocator.Allocate(arrayLengthThreshold + 1); - - Assert.False(Unsafe.AreSame(ref ptr2Small, ref large.GetReference())); - } - - [Fact] - public void CreateWithAggressivePooling() - { - if (!TestEnvironment.Is64BitProcess) - { - // can lead to OutOfMemoryException - return; - } - - this.MemoryAllocator = ArrayPoolMemoryAllocator.CreateWithAggressivePooling(); - - Assert.True(this.CheckIsRentingPooledBuffer(4096 * 4096)); - } - - [Fact] - public void CreateDefault() - { - if (!TestEnvironment.Is64BitProcess) - { - // can lead to OutOfMemoryException - return; - } - - this.MemoryAllocator = ArrayPoolMemoryAllocator.CreateDefault(); - - Assert.False(this.CheckIsRentingPooledBuffer(2 * 4096 * 4096)); - Assert.True(this.CheckIsRentingPooledBuffer(2048 * 2048)); - } - - [Fact] - public void CreateWithModeratePooling() - { - if (!TestEnvironment.Is64BitProcess) - { - // can lead to OutOfMemoryException - return; - } - - this.MemoryAllocator = ArrayPoolMemoryAllocator.CreateWithModeratePooling(); - - Assert.False(this.CheckIsRentingPooledBuffer(2048 * 2048)); - Assert.True(this.CheckIsRentingPooledBuffer(1024 * 16)); - } - } -} \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs b/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs index 301a76f562..19ec725f27 100644 --- a/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs +++ b/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs @@ -1,26 +1,27 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. -// ReSharper disable InconsistentNaming -namespace SixLabors.ImageSharp.Tests.Memory -{ - using System; - using System.Runtime.CompilerServices; - using System.Runtime.InteropServices; +using System; +using System.Buffers; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; - using SixLabors.ImageSharp.PixelFormats; - using SixLabors.Memory; - using SixLabors.ImageSharp.Tests.Common; - using SixLabors.Primitives; +using SixLabors.ImageSharp.Memory; +using SixLabors.Memory; +using SixLabors.Primitives; - using Xunit; +using Xunit; +// ReSharper disable InconsistentNaming + +namespace SixLabors.ImageSharp.Tests.Memory +{ public class Buffer2DTests { // ReSharper disable once ClassNeverInstantiated.Local private class Assert : Xunit.Assert { - public static void SpanPointsTo(Span span, IBuffer buffer, int bufferOffset = 0) + public static void SpanPointsTo(Span span, IMemoryOwner buffer, int bufferOffset = 0) where T : struct { ref T actual = ref MemoryMarshal.GetReference(span); @@ -30,31 +31,7 @@ namespace SixLabors.ImageSharp.Tests.Memory } } - private MemoryAllocator MemoryAllocator { get; } = new MockMemoryAllocator(); - - private class MockMemoryAllocator : MemoryAllocator - { - internal override IBuffer Allocate(int length, bool clear) - { - var array = new T[length + 42]; - - if (!clear) - { - Span data = MemoryMarshal.Cast(array.AsSpan()); - for (int i = 0; i < data.Length; i++) - { - data[i] = 42; - } - } - - return new BasicArrayBuffer(array, length); - } - - internal override IManagedByteBuffer AllocateManagedByteBuffer(int length, bool clear) - { - throw new NotImplementedException(); - } - } + private MemoryAllocator MemoryAllocator { get; } = new TestMemoryAllocator(); [Theory] [InlineData(7, 42)] @@ -65,14 +42,14 @@ namespace SixLabors.ImageSharp.Tests.Memory { Assert.Equal(width, buffer.Width); Assert.Equal(height, buffer.Height); - Assert.Equal(width * height, buffer.Buffer.Length()); + Assert.Equal(width * height, buffer.Memory.Length); } } [Fact] public void CreateClean() { - using (Buffer2D buffer = this.MemoryAllocator.Allocate2D(42, 42, true)) + using (Buffer2D buffer = this.MemoryAllocator.Allocate2D(42, 42, AllocationOptions.Clean)) { Span span = buffer.GetSpan(); for (int j = 0; j < span.Length; j++) @@ -94,7 +71,7 @@ namespace SixLabors.ImageSharp.Tests.Memory // Assert.Equal(width * y, span.Start); Assert.Equal(width, span.Length); - Assert.SpanPointsTo(span, buffer.Buffer, width * y); + Assert.SpanPointsTo(span, buffer.MemorySource.MemoryOwner, width * y); } } @@ -110,7 +87,7 @@ namespace SixLabors.ImageSharp.Tests.Memory // Assert.Equal(width * y + x, span.Start); Assert.Equal(width - x, span.Length); - Assert.SpanPointsTo(span, buffer.Buffer, width * y + x); + Assert.SpanPointsTo(span, buffer.MemorySource.MemoryOwner, width * y + x); } } @@ -122,7 +99,7 @@ namespace SixLabors.ImageSharp.Tests.Memory { using (Buffer2D buffer = this.MemoryAllocator.Allocate2D(width, height)) { - Span span = buffer.Buffer.GetSpan(); + Span span = buffer.MemorySource.GetSpan(); ref TestStructs.Foo actual = ref buffer[x, y]; @@ -131,92 +108,24 @@ namespace SixLabors.ImageSharp.Tests.Memory Assert.True(Unsafe.AreSame(ref expected, ref actual)); } } - - public class SwapOrCopyContent - { - private MemoryAllocator MemoryAllocator { get; } = new MockMemoryAllocator(); - - [Fact] - public void WhenBothBuffersAreMemoryOwners_ShouldSwap() - { - using (Buffer2D a = this.MemoryAllocator.Allocate2D(10, 5)) - using (Buffer2D b = this.MemoryAllocator.Allocate2D(3, 7)) - { - IBuffer aa = a.Buffer; - IBuffer bb = b.Buffer; - - Buffer2D.SwapOrCopyContent(a, b); - - Assert.Equal(bb, a.Buffer); - Assert.Equal(aa, b.Buffer); - - Assert.Equal(new Size(3, 7), a.Size()); - Assert.Equal(new Size(10, 5), b.Size()); - } - } - [Fact] - public void WhenDestIsNotMemoryOwner_SameSize_ShouldCopy() + [Fact] + public void SwapOrCopyContent() + { + using (Buffer2D a = this.MemoryAllocator.Allocate2D(10, 5)) + using (Buffer2D b = this.MemoryAllocator.Allocate2D(3, 7)) { - var data = new Rgba32[3 * 7]; - var color = new Rgba32(1, 2, 3, 4); - - var mmg = new TestMemoryManager(data); - var aBuff = new ConsumedBuffer(mmg.Memory); - - using (Buffer2D a = new Buffer2D(aBuff, 3, 7)) - { - IBuffer aa = a.Buffer; - - // Precondition: - Assert.Equal(aBuff, aa); + IMemoryOwner aa = a.MemorySource.MemoryOwner; + IMemoryOwner bb = b.MemorySource.MemoryOwner; - using (Buffer2D b = this.MemoryAllocator.Allocate2D(3, 7)) - { - IBuffer bb = b.Buffer; - bb.GetSpan()[10] = color; + Buffer2D.SwapOrCopyContent(a, b); - // Act: - Buffer2D.SwapOrCopyContent(a, b); + Assert.Equal(bb, a.MemorySource.MemoryOwner); + Assert.Equal(aa, b.MemorySource.MemoryOwner); - // Assert: - Assert.Equal(aBuff, a.Buffer); - Assert.Equal(bb, b.Buffer); - } - - // Assert: - Assert.Equal(color, a.Buffer.GetSpan()[10]); - } - } - - [Fact] - public void WhenDestIsNotMemoryOwner_DifferentSize_Throws() - { - var data = new Rgba32[3 * 7]; - var color = new Rgba32(1, 2, 3, 4); - data[10] = color; - - var mmg = new TestMemoryManager(data); - var aBuff = new ConsumedBuffer(mmg.Memory); - - using (Buffer2D a = new Buffer2D(aBuff, 3, 7)) - { - IBuffer aa = a.Buffer; - using (Buffer2D b = this.MemoryAllocator.Allocate2D(3, 8)) - { - IBuffer bb = b.Buffer; - - Assert.ThrowsAny( - () => - { - Buffer2D.SwapOrCopyContent(a, b); - }); - } - - Assert.Equal(color, a.Buffer.GetSpan()[10]); - } + Assert.Equal(new Size(3, 7), a.Size()); + Assert.Equal(new Size(10, 5), b.Size()); } - } } } \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs b/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs index bbf3505141..dc735e41b4 100644 --- a/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs +++ b/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs @@ -1,13 +1,13 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. +using System; +using SixLabors.ImageSharp.Memory; +using SixLabors.Primitives; +using Xunit; + // ReSharper disable InconsistentNaming namespace SixLabors.ImageSharp.Tests.Memory { - using System; - - using SixLabors.Memory; - using SixLabors.Primitives; - - using Xunit; - public class BufferAreaTests { [Fact] @@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Tests.Memory { using (var buffer = Configuration.Default.MemoryAllocator.Allocate2D(10, 20)) { - var rectangle = new Rectangle(3,2, 5, 6); + var rectangle = new Rectangle(3, 2, 5, 6); var area = new BufferArea(buffer, rectangle); Assert.Equal(buffer, area.DestinationBuffer); @@ -33,9 +33,10 @@ namespace SixLabors.ImageSharp.Tests.Memory buffer[x, y] = y * 100 + x; } } + return buffer; } - + [Theory] [InlineData(2, 3, 2, 2)] [InlineData(5, 4, 3, 2)] @@ -44,7 +45,7 @@ namespace SixLabors.ImageSharp.Tests.Memory using (Buffer2D buffer = CreateTestBuffer(20, 30)) { Rectangle r = new Rectangle(rx, ry, 5, 6); - + BufferArea area = buffer.GetArea(r); int value = area[x, y]; diff --git a/tests/ImageSharp.Tests/Memory/BufferTestSuite.cs b/tests/ImageSharp.Tests/Memory/BufferTestSuite.cs deleted file mode 100644 index a0a68a7058..0000000000 --- a/tests/ImageSharp.Tests/Memory/BufferTestSuite.cs +++ /dev/null @@ -1,329 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using SixLabors.Memory; -using Xunit; -// ReSharper disable InconsistentNaming - -namespace SixLabors.ImageSharp.Tests.Memory -{ - using System.Buffers; - - /// - /// Inherit this class to test an implementation (provided by ). - /// - public abstract class BufferTestSuite - { - protected BufferTestSuite(MemoryAllocator memoryAllocator) - { - this.MemoryAllocator = memoryAllocator; - } - - protected MemoryAllocator MemoryAllocator { get; } - - public struct CustomStruct : IEquatable - { - public long A; - - public byte B; - - public float C; - - public CustomStruct(long a, byte b, float c) - { - this.A = a; - this.B = b; - this.C = c; - } - - public bool Equals(CustomStruct other) - { - return this.A == other.A && this.B == other.B && this.C.Equals(other.C); - } - - public override bool Equals(object obj) - { - return obj is CustomStruct other && this.Equals(other); - } - - public override int GetHashCode() - { - unchecked - { - int hashCode = this.A.GetHashCode(); - hashCode = (hashCode * 397) ^ this.B.GetHashCode(); - hashCode = (hashCode * 397) ^ this.C.GetHashCode(); - return hashCode; - } - } - } - - public static readonly TheoryData LenthValues = new TheoryData { 0, 1, 7, 1023, 1024 }; - - [Fact] - public void IsMemoryOwner() - { - using (IBuffer buffer = this.MemoryAllocator.Allocate(42)) - { - Assert.True(buffer.IsMemoryOwner); - } - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void HasCorrectLength_byte(int desiredLength) - { - this.TestHasCorrectLength(desiredLength); - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void HasCorrectLength_float(int desiredLength) - { - this.TestHasCorrectLength(desiredLength); - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void HasCorrectLength_CustomStruct(int desiredLength) - { - this.TestHasCorrectLength(desiredLength); - } - - private void TestHasCorrectLength(int desiredLength) - where T : struct - { - using (IBuffer buffer = this.MemoryAllocator.Allocate(desiredLength)) - { - Assert.Equal(desiredLength, buffer.GetSpan().Length); - } - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void CanAllocateCleanBuffer_byte(int desiredLength) - { - this.TestCanAllocateCleanBuffer(desiredLength, false); - this.TestCanAllocateCleanBuffer(desiredLength, true); - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void CanAllocateCleanBuffer_double(int desiredLength) - { - this.TestCanAllocateCleanBuffer(desiredLength); - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void CanAllocateCleanBuffer_CustomStruct(int desiredLength) - { - this.TestCanAllocateCleanBuffer(desiredLength); - } - - private IBuffer Allocate(int desiredLength, bool clean, bool managedByteBuffer) - where T : struct - { - if (managedByteBuffer) - { - if (!(this.MemoryAllocator.AllocateManagedByteBuffer(desiredLength, clean) is IBuffer buffer)) - { - throw new InvalidOperationException("typeof(T) != typeof(byte)"); - } - - return buffer; - } - - return this.MemoryAllocator.Allocate(desiredLength, clean); - } - - private void TestCanAllocateCleanBuffer(int desiredLength, bool testManagedByteBuffer = false) - where T : struct, IEquatable - { - ReadOnlySpan expected = new T[desiredLength]; - - for (int i = 0; i < 10; i++) - { - using (IBuffer buffer = this.Allocate(desiredLength, true, testManagedByteBuffer)) - { - Assert.True(buffer.GetSpan().SequenceEqual(expected)); - } - } - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void SpanPropertyIsAlwaysTheSame_int(int desiredLength) - { - this.TestSpanPropertyIsAlwaysTheSame(desiredLength); - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void SpanPropertyIsAlwaysTheSame_byte(int desiredLength) - { - this.TestSpanPropertyIsAlwaysTheSame(desiredLength, false); - this.TestSpanPropertyIsAlwaysTheSame(desiredLength, true); - } - - private void TestSpanPropertyIsAlwaysTheSame(int desiredLength, bool testManagedByteBuffer = false) - where T : struct - { - using (IBuffer buffer = this.Allocate(desiredLength, false, testManagedByteBuffer)) - { - ref T a = ref MemoryMarshal.GetReference(buffer.GetSpan()); - ref T b = ref MemoryMarshal.GetReference(buffer.GetSpan()); - ref T c = ref MemoryMarshal.GetReference(buffer.GetSpan()); - - Assert.True(Unsafe.AreSame(ref a, ref b)); - Assert.True(Unsafe.AreSame(ref b, ref c)); - } - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void WriteAndReadElements_float(int desiredLength) - { - this.TestWriteAndReadElements(desiredLength, x => x * 1.2f); - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void WriteAndReadElements_byte(int desiredLength) - { - this.TestWriteAndReadElements(desiredLength, x => (byte)(x+1), false); - this.TestWriteAndReadElements(desiredLength, x => (byte)(x + 1), true); - } - - private void TestWriteAndReadElements(int desiredLength, Func getExpectedValue, bool testManagedByteBuffer = false) - where T : struct - { - using (IBuffer buffer = this.Allocate(desiredLength, false, testManagedByteBuffer)) - { - T[] expectedVals = new T[buffer.Length()]; - - for (int i = 0; i < buffer.Length(); i++) - { - Span span = buffer.GetSpan(); - expectedVals[i] = getExpectedValue(i); - span[i] = expectedVals[i]; - } - - for (int i = 0; i < buffer.Length(); i++) - { - Span span = buffer.GetSpan(); - Assert.Equal(expectedVals[i], span[i]); - } - } - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void IndexingSpan_WhenOutOfRange_Throws_byte(int desiredLength) - { - this.TestIndexOutOfRangeShouldThrow(desiredLength, false); - this.TestIndexOutOfRangeShouldThrow(desiredLength, true); - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void IndexingSpan_WhenOutOfRange_Throws_long(int desiredLength) - { - this.TestIndexOutOfRangeShouldThrow(desiredLength); - } - - [Theory] - [MemberData(nameof(LenthValues))] - public void IndexingSpan_WhenOutOfRange_Throws_CustomStruct(int desiredLength) - { - this.TestIndexOutOfRangeShouldThrow(desiredLength); - } - - private T TestIndexOutOfRangeShouldThrow(int desiredLength, bool testManagedByteBuffer = false) - where T : struct, IEquatable - { - var dummy = default(T); - - using (IBuffer buffer = this.Allocate(desiredLength, false, testManagedByteBuffer)) - { - Assert.ThrowsAny( - () => - { - Span span = buffer.GetSpan(); - dummy = span[desiredLength]; - }); - - Assert.ThrowsAny( - () => - { - Span span = buffer.GetSpan(); - dummy = span[desiredLength + 1]; - }); - - Assert.ThrowsAny( - () => - { - Span span = buffer.GetSpan(); - dummy = span[desiredLength + 42]; - }); - } - - return dummy; - } - - [Theory] - [InlineData(1)] - [InlineData(7)] - [InlineData(1024)] - [InlineData(6666)] - public void ManagedByteBuffer_ArrayIsCorrect(int desiredLength) - { - using (IManagedByteBuffer buffer = this.MemoryAllocator.AllocateManagedByteBuffer(desiredLength)) - { - ref byte array0 = ref buffer.Array[0]; - ref byte span0 = ref buffer.GetReference(); - - Assert.True(Unsafe.AreSame(ref span0, ref array0)); - Assert.True(buffer.Array.Length >= buffer.GetSpan().Length); - } - } - - [Fact] - public void GetMemory_ReturnsValidMemory() - { - using (IBuffer buffer = this.MemoryAllocator.Allocate(42)) - { - Span span0 = buffer.GetSpan(); - span0[10].A = 30; - Memory memory = buffer.Memory; - - Assert.Equal(42, memory.Length); - Span span1 = memory.Span; - - Assert.Equal(42, span1.Length); - Assert.Equal(30, span1[10].A); - } - } - - [Fact] - public unsafe void GetMemory_ResultIsPinnable() - { - using (IBuffer buffer = this.MemoryAllocator.Allocate(42)) - { - Span span0 = buffer.GetSpan(); - span0[10] = 30; - - Memory memory = buffer.Memory; - - using (MemoryHandle h = memory.Pin()) - { - int* ptr = (int*) h.Pointer; - Assert.Equal(30, ptr[10]); - } - } - } - } -} \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Memory/MemorySourceTests.cs b/tests/ImageSharp.Tests/Memory/MemorySourceTests.cs new file mode 100644 index 0000000000..21217d73f2 --- /dev/null +++ b/tests/ImageSharp.Tests/Memory/MemorySourceTests.cs @@ -0,0 +1,162 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System; +using System.Buffers; +using SixLabors.ImageSharp.Memory; +using SixLabors.ImageSharp.PixelFormats; +using SixLabors.Memory; +using Xunit; + +// ReSharper disable InconsistentNaming +namespace SixLabors.ImageSharp.Tests.Memory +{ + public class MemorySourceTests + { + public class Construction + { + [Theory] + [InlineData(false)] + [InlineData(true)] + public void InitializeAsOwner(bool isInternalMemorySource) + { + var data = new Rgba32[21]; + var mmg = new TestMemoryManager(data); + + var a = new MemorySource(mmg, isInternalMemorySource); + + Assert.Equal(mmg, a.MemoryOwner); + Assert.Equal(mmg.Memory, a.Memory); + Assert.Equal(isInternalMemorySource, a.HasSwappableContents); + } + + [Fact] + public void InitializeAsObserver_MemoryOwner_IsNull() + { + var data = new Rgba32[21]; + var mmg = new TestMemoryManager(data); + + var a = new MemorySource(mmg.Memory); + + Assert.Null(a.MemoryOwner); + Assert.Equal(mmg.Memory, a.Memory); + Assert.False(a.HasSwappableContents); + } + } + + public class Dispose + { + [Theory] + [InlineData(false)] + [InlineData(true)] + public void WhenOwnershipIsTransfered_ShouldDisposeMemoryOwner(bool isInternalMemorySource) + { + var mmg = new TestMemoryManager(new int[10]); + var bmg = new MemorySource(mmg, isInternalMemorySource); + + bmg.Dispose(); + Assert.True(mmg.IsDisposed); + } + + [Fact] + public void WhenMemoryObserver_ShouldNotDisposeAnything() + { + var mmg = new TestMemoryManager(new int[10]); + var bmg = new MemorySource(mmg.Memory); + + bmg.Dispose(); + Assert.False(mmg.IsDisposed); + } + } + + public class SwapOrCopyContent + { + private MemoryAllocator MemoryAllocator { get; } = new TestMemoryAllocator(); + + private MemorySource AllocateMemorySource(int length, AllocationOptions options = AllocationOptions.None) + where T : struct + { + IMemoryOwner owner = this.MemoryAllocator.Allocate(length, options); + return new MemorySource(owner, true); + } + + [Fact] + public void WhenBothAreMemoryOwners_ShouldSwap() + { + MemorySource a = this.AllocateMemorySource(13); + MemorySource b = this.AllocateMemorySource(17); + + IMemoryOwner aa = a.MemoryOwner; + IMemoryOwner bb = b.MemoryOwner; + + Memory aaa = a.Memory; + Memory bbb = b.Memory; + + MemorySource.SwapOrCopyContent(ref a, ref b); + + Assert.Equal(bb, a.MemoryOwner); + Assert.Equal(aa, b.MemoryOwner); + + Assert.Equal(bbb, a.Memory); + Assert.Equal(aaa, b.Memory); + Assert.NotEqual(a.Memory, b.Memory); + } + + [Theory] + [InlineData(false, false)] + [InlineData(true, true)] + [InlineData(true, false)] + public void WhenDestIsNotMemoryOwner_SameSize_ShouldCopy(bool sourceIsOwner, bool isInternalMemorySource) + { + var data = new Rgba32[21]; + var color = new Rgba32(1, 2, 3, 4); + + var destOwner = new TestMemoryManager(data); + var dest = new MemorySource(destOwner.Memory); + + IMemoryOwner sourceOwner = this.MemoryAllocator.Allocate(21); + + MemorySource source = sourceIsOwner + ? new MemorySource(sourceOwner, isInternalMemorySource) + : new MemorySource(sourceOwner.Memory); + + sourceOwner.Memory.Span[10] = color; + + // Act: + MemorySource.SwapOrCopyContent(ref dest, ref source); + + // Assert: + Assert.Equal(color, dest.Memory.Span[10]); + Assert.NotEqual(sourceOwner, dest.MemoryOwner); + Assert.NotEqual(destOwner, source.MemoryOwner); + } + + [Theory] + [InlineData(false)] + [InlineData(true)] + public void WhenDestIsNotMemoryOwner_DifferentSize_Throws(bool sourceIsOwner) + { + var data = new Rgba32[21]; + var color = new Rgba32(1, 2, 3, 4); + + var destOwner = new TestMemoryManager(data); + var dest = new MemorySource(destOwner.Memory); + + IMemoryOwner sourceOwner = this.MemoryAllocator.Allocate(22); + + MemorySource source = sourceIsOwner + ? new MemorySource(sourceOwner, true) + : new MemorySource(sourceOwner.Memory); + sourceOwner.Memory.Span[10] = color; + + // Act: + Assert.ThrowsAny( + () => MemorySource.SwapOrCopyContent(ref dest, ref source) + ); + + Assert.Equal(color, source.Memory.Span[10]); + Assert.NotEqual(color, dest.Memory.Span[10]); + } + } + } +} \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Memory/SimpleGcMemoryManagerTests.cs b/tests/ImageSharp.Tests/Memory/SimpleGcMemoryManagerTests.cs deleted file mode 100644 index d04336690c..0000000000 --- a/tests/ImageSharp.Tests/Memory/SimpleGcMemoryManagerTests.cs +++ /dev/null @@ -1,15 +0,0 @@ -namespace SixLabors.ImageSharp.Tests.Memory -{ - using SixLabors.Memory; - - public class SimpleGcMemoryManagerTests - { - public class BufferTests : BufferTestSuite - { - public BufferTests() - : base(new SimpleGcMemoryAllocator()) - { - } - } - } -} \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Memory/SpanUtilityTests.cs b/tests/ImageSharp.Tests/Memory/SpanUtilityTests.cs deleted file mode 100644 index 396fb4ca99..0000000000 --- a/tests/ImageSharp.Tests/Memory/SpanUtilityTests.cs +++ /dev/null @@ -1,263 +0,0 @@ -// Copyright (c) Six Labors and contributors. -// Licensed under the Apache License, Version 2.0. - -// ReSharper disable InconsistentNaming -// ReSharper disable AccessToStaticMemberViaDerivedType -namespace SixLabors.ImageSharp.Tests.Memory -{ - using System; - using System.Runtime.CompilerServices; - using System.Runtime.InteropServices; - using Xunit; - - public unsafe class SpanUtilityTests - { - // ReSharper disable once ClassNeverInstantiated.Local - private class Assert : Xunit.Assert - { - public static void SameRefs(ref T1 a, ref T2 b) - { - ref T1 bb = ref Unsafe.As(ref b); - - Assert.True(Unsafe.AreSame(ref a, ref bb), "References are not same!"); - } - } - - public class SpanHelper_Copy - { - private static void AssertNotDefault(T[] data, int idx) - where T : struct - { - Assert.NotEqual(default, data[idx]); - } - - private static byte[] CreateTestBytes(int count) - { - byte[] result = new byte[count]; - for (int i = 0; i < result.Length; i++) - { - result[i] = (byte)((i % 200) + 1); - } - return result; - } - - private static int[] CreateTestInts(int count) - { - int[] result = new int[count]; - for (int i = 0; i < result.Length; i++) - { - result[i] = i + 1; - } - return result; - } - - [Theory] - [InlineData(4)] - [InlineData(1500)] - public void GenericToOwnType(int count) - { - TestStructs.Foo[] source = TestStructs.Foo.CreateArray(count + 2); - var dest = new TestStructs.Foo[count + 5]; - - var apSource = new Span(source, 1, source.Length - 1); - var apDest = new Span(dest, 1, dest.Length - 1); - - apSource.Slice(0, count - 1).CopyTo(apDest); - - AssertNotDefault(source, 1); - AssertNotDefault(dest, 1); - - Assert.NotEqual(source[0], dest[0]); - Assert.Equal(source[1], dest[1]); - Assert.Equal(source[2], dest[2]); - Assert.Equal(source[count - 1], dest[count - 1]); - Assert.NotEqual(source[count], dest[count]); - } - - [Theory] - [InlineData(4)] - [InlineData(1500)] - public void GenericToOwnType_Aligned(int count) - { - TestStructs.AlignedFoo[] source = TestStructs.AlignedFoo.CreateArray(count + 2); - var dest = new TestStructs.AlignedFoo[count + 5]; - - var apSource = new Span(source, 1, source.Length - 1); - var apDest = new Span(dest, 1, dest.Length - 1); - - apSource.Slice(0, count - 1).CopyTo(apDest); - - AssertNotDefault(source, 1); - AssertNotDefault(dest, 1); - - Assert.NotEqual(source[0], dest[0]); - Assert.Equal(source[1], dest[1]); - Assert.Equal(source[2], dest[2]); - Assert.Equal(source[count - 1], dest[count - 1]); - Assert.NotEqual(source[count], dest[count]); - } - - [Theory] - [InlineData(4)] - [InlineData(1500)] - public void IntToInt(int count) - { - int[] source = CreateTestInts(count + 2); - int[] dest = new int[count + 5]; - - var apSource = new Span(source, 1, source.Length - 1); - var apDest = new Span(dest, 1, dest.Length - 1); - - apSource.Slice(0, count - 1).CopyTo(apDest); - - AssertNotDefault(source, 1); - AssertNotDefault(dest, 1); - - Assert.NotEqual(source[0], dest[0]); - Assert.Equal(source[1], dest[1]); - Assert.Equal(source[2], dest[2]); - Assert.Equal(source[count - 1], dest[count - 1]); - Assert.NotEqual(source[count], dest[count]); - } - - [Theory] - [InlineData(4)] - [InlineData(1500)] - public void GenericToBytes(int count) - { - int destCount = count * sizeof(TestStructs.Foo); - TestStructs.Foo[] source = TestStructs.Foo.CreateArray(count + 2); - byte[] dest = new byte[destCount + sizeof(TestStructs.Foo) * 2]; - - var apSource = new Span(source, 1, source.Length - 1); - var apDest = new Span(dest, sizeof(TestStructs.Foo), dest.Length - sizeof(TestStructs.Foo)); - - MemoryMarshal.AsBytes(apSource).Slice(0, (count - 1) * sizeof(TestStructs.Foo)).CopyTo(apDest); - - AssertNotDefault(source, 1); - - Assert.False((bool)ElementsAreEqual(source, dest, 0)); - Assert.True((bool)ElementsAreEqual(source, dest, 1)); - Assert.True((bool)ElementsAreEqual(source, dest, 2)); - Assert.True((bool)ElementsAreEqual(source, dest, count - 1)); - Assert.False((bool)ElementsAreEqual(source, dest, count)); - } - - [Theory] - [InlineData(4)] - [InlineData(1500)] - public void GenericToBytes_Aligned(int count) - { - int destCount = count * sizeof(TestStructs.Foo); - TestStructs.AlignedFoo[] source = TestStructs.AlignedFoo.CreateArray(count + 2); - byte[] dest = new byte[destCount + sizeof(TestStructs.AlignedFoo) * 2]; - - var apSource = new Span(source, 1, source.Length - 1); - var apDest = new Span(dest, sizeof(TestStructs.AlignedFoo), dest.Length - sizeof(TestStructs.AlignedFoo)); - - MemoryMarshal.AsBytes(apSource).Slice(0, (count - 1) * sizeof(TestStructs.AlignedFoo)).CopyTo(apDest); - - AssertNotDefault(source, 1); - - Assert.False((bool)ElementsAreEqual(source, dest, 0)); - Assert.True((bool)ElementsAreEqual(source, dest, 1)); - Assert.True((bool)ElementsAreEqual(source, dest, 2)); - Assert.True((bool)ElementsAreEqual(source, dest, count - 1)); - Assert.False((bool)ElementsAreEqual(source, dest, count)); - } - - [Theory] - [InlineData(4)] - [InlineData(1500)] - public void IntToBytes(int count) - { - int destCount = count * sizeof(int); - int[] source = CreateTestInts(count + 2); - byte[] dest = new byte[destCount + sizeof(int) + 1]; - - var apSource = new Span(source); - var apDest = new Span(dest); - - MemoryMarshal.AsBytes(apSource).Slice(0, count * sizeof(int)).CopyTo(apDest); - - AssertNotDefault(source, 1); - - Assert.True((bool)ElementsAreEqual(source, dest, 0)); - Assert.True((bool)ElementsAreEqual(source, dest, count - 1)); - Assert.False((bool)ElementsAreEqual(source, dest, count)); - } - - [Theory] - [InlineData(4)] - [InlineData(1500)] - public void BytesToGeneric(int count) - { - int srcCount = count * sizeof(TestStructs.Foo); - byte[] source = CreateTestBytes(srcCount); - var dest = new TestStructs.Foo[count + 2]; - - var apSource = new Span(source); - var apDest = new Span(dest); - - apSource.Slice(0, count * sizeof(TestStructs.Foo)).CopyTo(MemoryMarshal.AsBytes(apDest)); - - AssertNotDefault(source, sizeof(TestStructs.Foo) + 1); - AssertNotDefault(dest, 1); - - Assert.True((bool)ElementsAreEqual(dest, source, 0)); - Assert.True((bool)ElementsAreEqual(dest, source, 1)); - Assert.True((bool)ElementsAreEqual(dest, source, count - 1)); - - // Difference is 2.4380727671472639E-289 - // 32 bit doesn't compare accuarately enough and is blocking our PR's - // TODO: Refactor a better test. - if (Environment.Is64BitProcess) - { - Assert.False((bool)ElementsAreEqual(dest, source, count)); - } - } - - internal static bool ElementsAreEqual(TestStructs.Foo[] array, byte[] rawArray, int index) - { - fixed (TestStructs.Foo* pArray = array) - fixed (byte* pRaw = rawArray) - { - var pCasted = (TestStructs.Foo*)pRaw; - - TestStructs.Foo val1 = pArray[index]; - TestStructs.Foo val2 = pCasted[index]; - - return val1.Equals(val2); - } - } - - internal static bool ElementsAreEqual(TestStructs.AlignedFoo[] array, byte[] rawArray, int index) - { - fixed (TestStructs.AlignedFoo* pArray = array) - fixed (byte* pRaw = rawArray) - { - var pCasted = (TestStructs.AlignedFoo*)pRaw; - - TestStructs.AlignedFoo val1 = pArray[index]; - TestStructs.AlignedFoo val2 = pCasted[index]; - - return val1.Equals(val2); - } - } - - internal static bool ElementsAreEqual(int[] array, byte[] rawArray, int index) - { - fixed (int* pArray = array) - fixed (byte* pRaw = rawArray) - { - int* pCasted = (int*)pRaw; - - int val1 = pArray[index]; - int val2 = pCasted[index]; - - return val1.Equals(val2); - } - } - } - } -} \ No newline at end of file diff --git a/tests/ImageSharp.Tests/MetaData/ImageMetaDataTests.cs b/tests/ImageSharp.Tests/MetaData/ImageMetaDataTests.cs index 255451e0e6..8934ebc361 100644 --- a/tests/ImageSharp.Tests/MetaData/ImageMetaDataTests.cs +++ b/tests/ImageSharp.Tests/MetaData/ImageMetaDataTests.cs @@ -1,6 +1,7 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. +using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.MetaData.Profiles.Exif; using SixLabors.ImageSharp.PixelFormats; diff --git a/tests/ImageSharp.Tests/MetaData/Profiles/Exif/ExifProfileTests.cs b/tests/ImageSharp.Tests/MetaData/Profiles/Exif/ExifProfileTests.cs index 3c69b57fd2..3deb382ea6 100644 --- a/tests/ImageSharp.Tests/MetaData/Profiles/Exif/ExifProfileTests.cs +++ b/tests/ImageSharp.Tests/MetaData/Profiles/Exif/ExifProfileTests.cs @@ -3,9 +3,11 @@ using System; using System.Collections; +using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; +using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; using SixLabors.ImageSharp.MetaData; using SixLabors.ImageSharp.MetaData.Profiles.Exif; using SixLabors.ImageSharp.PixelFormats; @@ -17,8 +19,27 @@ namespace SixLabors.ImageSharp.Tests { public class ExifProfileTests { - [Fact] - public void Constructor() + public enum TestImageWriteFormat + { + Jpeg, + Png + } + + private static readonly Dictionary TestProfileValues = new Dictionary() + { + { ExifTag.Software, "Software" }, + { ExifTag.Copyright, "Copyright" }, + { ExifTag.Orientation, (ushort)5 }, + { ExifTag.ShutterSpeedValue, new SignedRational(75.55) }, + { ExifTag.ImageDescription, "ImageDescription" }, + { ExifTag.ExposureTime, new Rational(1.0 / 1600.0) }, + { ExifTag.Model, "Model" }, + }; + + [Theory] + [InlineData(TestImageWriteFormat.Jpeg)] + [InlineData(TestImageWriteFormat.Png)] + public void Constructor(TestImageWriteFormat imageFormat) { Image image = TestFile.Create(TestImages.Jpeg.Baseline.Calliphora).CreateImage(); @@ -27,7 +48,7 @@ namespace SixLabors.ImageSharp.Tests image.MetaData.ExifProfile = new ExifProfile(); image.MetaData.ExifProfile.SetValue(ExifTag.Copyright, "Dirk Lemstra"); - image = WriteAndRead(image); + image = WriteAndRead(image, imageFormat); Assert.NotNull(image.MetaData.ExifProfile); Assert.Equal(1, image.MetaData.ExifProfile.Values.Count()); @@ -50,7 +71,7 @@ namespace SixLabors.ImageSharp.Tests ExifProfile profile = GetExifProfile(); - ExifProfile clone = new ExifProfile(profile); + var clone = new ExifProfile(profile); TestProfile(clone); profile.SetValue(ExifTag.ColorSpace, (ushort)2); @@ -59,10 +80,12 @@ namespace SixLabors.ImageSharp.Tests TestProfile(clone); } - [Fact] - public void WriteFraction() + [Theory] + [InlineData(TestImageWriteFormat.Jpeg)] + [InlineData(TestImageWriteFormat.Png)] + public void WriteFraction(TestImageWriteFormat imageFormat) { - using (MemoryStream memStream = new MemoryStream()) + using (var memStream = new MemoryStream()) { double exposureTime = 1.0 / 1600; @@ -70,13 +93,10 @@ namespace SixLabors.ImageSharp.Tests profile.SetValue(ExifTag.ExposureTime, new Rational(exposureTime)); - Image image = new Image(1, 1); + var image = new Image(1, 1); image.MetaData.ExifProfile = profile; - image.SaveAsJpeg(memStream); - - memStream.Position = 0; - image = Image.Load(memStream); + image = WriteAndRead(image, imageFormat); profile = image.MetaData.ExifProfile; Assert.NotNull(profile); @@ -91,10 +111,7 @@ namespace SixLabors.ImageSharp.Tests profile.SetValue(ExifTag.ExposureTime, new Rational(exposureTime, true)); image.MetaData.ExifProfile = profile; - image.SaveAsJpeg(memStream); - - memStream.Position = 0; - image = Image.Load(memStream); + image = WriteAndRead(image, imageFormat); profile = image.MetaData.ExifProfile; Assert.NotNull(profile); @@ -104,36 +121,40 @@ namespace SixLabors.ImageSharp.Tests } } - [Fact] - public void ReadWriteInfinity() + [Theory] + [InlineData(TestImageWriteFormat.Jpeg)] + [InlineData(TestImageWriteFormat.Png)] + public void ReadWriteInfinity(TestImageWriteFormat imageFormat) { Image image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateImage(); image.MetaData.ExifProfile.SetValue(ExifTag.ExposureBiasValue, new SignedRational(double.PositiveInfinity)); - image = WriteAndRead(image); + image = WriteAndReadJpeg(image); ExifValue value = image.MetaData.ExifProfile.GetValue(ExifTag.ExposureBiasValue); Assert.NotNull(value); Assert.Equal(new SignedRational(double.PositiveInfinity), value.Value); image.MetaData.ExifProfile.SetValue(ExifTag.ExposureBiasValue, new SignedRational(double.NegativeInfinity)); - image = WriteAndRead(image); + image = WriteAndRead(image, imageFormat); value = image.MetaData.ExifProfile.GetValue(ExifTag.ExposureBiasValue); Assert.NotNull(value); Assert.Equal(new SignedRational(double.NegativeInfinity), value.Value); image.MetaData.ExifProfile.SetValue(ExifTag.FlashEnergy, new Rational(double.NegativeInfinity)); - image = WriteAndRead(image); + image = WriteAndRead(image, imageFormat); value = image.MetaData.ExifProfile.GetValue(ExifTag.FlashEnergy); Assert.NotNull(value); Assert.Equal(new Rational(double.PositiveInfinity), value.Value); } - [Fact] - public void SetValue() + [Theory] + [InlineData(TestImageWriteFormat.Jpeg)] + [InlineData(TestImageWriteFormat.Png)] + public void SetValue(TestImageWriteFormat imageFormat) { - Rational[] latitude = new Rational[] { new Rational(12.3), new Rational(4.56), new Rational(789.0) }; + var latitude = new Rational[] { new Rational(12.3), new Rational(4.56), new Rational(789.0) }; Image image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateImage(); image.MetaData.ExifProfile.SetValue(ExifTag.Software, "ImageSharp"); @@ -171,7 +192,7 @@ namespace SixLabors.ImageSharp.Tests value = image.MetaData.ExifProfile.GetValue(ExifTag.GPSLatitude); TestValue(value, latitude); - image = WriteAndRead(image); + image = WriteAndRead(image, imageFormat); Assert.NotNull(image.MetaData.ExifProfile); Assert.Equal(17, image.MetaData.ExifProfile.Values.Count()); @@ -193,7 +214,7 @@ namespace SixLabors.ImageSharp.Tests image.MetaData.ExifProfile.Parts = ExifParts.ExifTags; - image = WriteAndRead(image); + image = WriteAndRead(image, imageFormat); Assert.NotNull(image.MetaData.ExifProfile); Assert.Equal(8, image.MetaData.ExifProfile.Values.Count()); @@ -252,22 +273,36 @@ namespace SixLabors.ImageSharp.Tests Assert.Equal(170, thumbnail.Height); } - [Fact] - public void WriteTooLargeProfile() + [Theory] + [InlineData(ExifTag.Software)] + [InlineData(ExifTag.Copyright)] + [InlineData(ExifTag.Model)] + [InlineData(ExifTag.ImageDescription)] + public void ReadWriteLargeProfileJpg(ExifTag exifValueToChange) { + // arrange var junk = new StringBuilder(); - for (int i = 0; i < 65500; i++) + for (int i = 0; i < 65600; i++) { - junk.Append("I"); + junk.Append("a"); } - var image = new Image(100, 100); - image.MetaData.ExifProfile = new ExifProfile(); - image.MetaData.ExifProfile.SetValue(ExifTag.ImageDescription, junk.ToString()); - - using (var memStream = new MemoryStream()) + ExifProfile expectedProfile = CreateExifProfile(); + var expectedProfileTags = expectedProfile.Values.Select(x => x.Tag).ToList(); + expectedProfile.SetValue(exifValueToChange, junk.ToString()); + image.MetaData.ExifProfile = expectedProfile; + + // act + Image reloadedImage = WriteAndRead(image, TestImageWriteFormat.Jpeg); + + // assert + ExifProfile actualProfile = reloadedImage.MetaData.ExifProfile; + Assert.NotNull(actualProfile); + foreach (ExifTag expectedProfileTag in expectedProfileTags) { - Assert.Throws(() => image.SaveAsJpeg(memStream)); + ExifValue actualProfileValue = actualProfile.GetValue(expectedProfileTag); + ExifValue expectedProfileValue = expectedProfile.GetValue(expectedProfileTag); + Assert.Equal(expectedProfileValue.Value, actualProfileValue.Value); } } @@ -305,10 +340,71 @@ namespace SixLabors.ImageSharp.Tests Assert.Equal(24, profile.Values.Count); byte[] bytes = profile.ToByteArray(); - Assert.Equal(495, bytes.Length); + Assert.Equal(489, bytes.Length); + } + + [Theory] + [InlineData(TestImageWriteFormat.Jpeg)] + [InlineData(TestImageWriteFormat.Png)] + public void WritingImagePreservesExifProfile(TestImageWriteFormat imageFormat) + { + // arrange + var image = new Image(1, 1); + ExifProfile expected = CreateExifProfile(); + image.MetaData.ExifProfile = expected; + + // act + Image reloadedImage = WriteAndRead(image, imageFormat); + + // assert + ExifProfile actual = reloadedImage.MetaData.ExifProfile; + Assert.NotNull(actual); + foreach(KeyValuePair expectedProfileValue in TestProfileValues) + { + ExifValue actualProfileValue = actual.GetValue(expectedProfileValue.Key); + Assert.NotNull(actualProfileValue); + Assert.Equal(expectedProfileValue.Value, actualProfileValue.Value); + } + } + + [Fact] + public void ProfileToByteArray() + { + // arrange + byte[] exifBytesWithExifCode = ProfileResolver.ExifMarker.Concat(ExifConstants.LittleEndianByteOrderMarker).ToArray(); + byte[] exifBytesWithoutExifCode = ExifConstants.LittleEndianByteOrderMarker; + ExifProfile expectedProfile = CreateExifProfile(); + var expectedProfileTags = expectedProfile.Values.Select(x => x.Tag).ToList(); + + // act + byte[] actualBytes = expectedProfile.ToByteArray(); + var actualProfile = new ExifProfile(actualBytes); + + // assert + Assert.NotNull(actualBytes); + Assert.NotEmpty(actualBytes); + Assert.Equal(exifBytesWithoutExifCode, actualBytes.Take(exifBytesWithoutExifCode.Length).ToArray()); + foreach(ExifTag expectedProfileTag in expectedProfileTags) + { + ExifValue actualProfileValue = actualProfile.GetValue(expectedProfileTag); + ExifValue expectedProfileValue = expectedProfile.GetValue(expectedProfileTag); + Assert.Equal(expectedProfileValue.Value, actualProfileValue.Value); + } } - private static ExifProfile GetExifProfile() + private static ExifProfile CreateExifProfile() + { + var profile = new ExifProfile(); + + foreach(KeyValuePair exifProfileValue in TestProfileValues) + { + profile.SetValue(exifProfileValue.Key, exifProfileValue.Value); + } + + return profile; + } + + internal static ExifProfile GetExifProfile() { Image image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateImage(); @@ -318,9 +414,22 @@ namespace SixLabors.ImageSharp.Tests return profile; } - private static Image WriteAndRead(Image image) + private static Image WriteAndRead(Image image, TestImageWriteFormat imageFormat) { - using (MemoryStream memStream = new MemoryStream()) + switch(imageFormat) + { + case TestImageWriteFormat.Jpeg: + return WriteAndReadJpeg(image); + case TestImageWriteFormat.Png: + return WriteAndReadPng(image); + default: + throw new ArgumentException("unexpected test image format, only Jpeg and Png are allowed"); + } + } + + private static Image WriteAndReadJpeg(Image image) + { + using (var memStream = new MemoryStream()) { image.SaveAsJpeg(memStream); image.Dispose(); @@ -330,6 +439,18 @@ namespace SixLabors.ImageSharp.Tests } } + private static Image WriteAndReadPng(Image image) + { + using (var memStream = new MemoryStream()) + { + image.SaveAsPng(memStream); + image.Dispose(); + + memStream.Position = 0; + return Image.Load(memStream); + } + } + private static void TestProfile(ExifProfile profile) { Assert.NotNull(profile); @@ -341,13 +462,19 @@ namespace SixLabors.ImageSharp.Tests Assert.NotNull(value.Value); if (value.Tag == ExifTag.Software) + { Assert.Equal("Windows Photo Editor 10.0.10011.16384", value.ToString()); + } if (value.Tag == ExifTag.XResolution) + { Assert.Equal(new Rational(300.0), value.Value); + } if (value.Tag == ExifTag.PixelXDimension) + { Assert.Equal(2338U, value.Value); + } } } diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs index c0e69a9027..e084379ba4 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs @@ -2,10 +2,11 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Numerics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -using SixLabors.Memory; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using Xunit; using Xunit.Abstractions; @@ -57,8 +58,8 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats int times = 200000; int count = 1024; - using (IBuffer source = Configuration.Default.MemoryAllocator.Allocate(count)) - using (IBuffer dest = Configuration.Default.MemoryAllocator.Allocate(count)) + using (IMemoryOwner source = Configuration.Default.MemoryAllocator.Allocate(count)) + using (IMemoryOwner dest = Configuration.Default.MemoryAllocator.Allocate(count)) { this.Measure( times, @@ -537,7 +538,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats where TDest : struct { public TSource[] SourceBuffer { get; } - public IBuffer ActualDestBuffer { get; } + public IMemoryOwner ActualDestBuffer { get; } public TDest[] ExpectedDestBuffer { get; } public TestBuffers(TSource[] source, TDest[] expectedDest) @@ -586,7 +587,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats internal static void TestOperation( TSource[] source, TDest[] expected, - Action> action) + Action> action) where TSource : struct where TDest : struct { diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/AutoOrientTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/AutoOrientTests.cs index d31f999d00..9b37fb266a 100644 --- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/AutoOrientTests.cs +++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/AutoOrientTests.cs @@ -5,12 +5,11 @@ using System; using SixLabors.ImageSharp.MetaData.Profiles.Exif; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; +using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; using Xunit; namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms { - using SixLabors.ImageSharp.Processing; - public class AutoOrientTests : FileTestBase { public static readonly string[] FlipFiles = { TestImages.Bmp.F }; diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeTests.cs index c7efbb1e0c..746d8da16e 100644 --- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeTests.cs +++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeTests.cs @@ -3,6 +3,7 @@ using System; +using SixLabors.ImageSharp.Advanced; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; using SixLabors.ImageSharp.Processing.Processors.Transforms; @@ -91,7 +92,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms { using (Image image0 = provider.GetImage()) { - var mmg = TestMemoryManager.CreateAsCopyOfPixelData(image0); + var mmg = TestMemoryManager.CreateAsCopyOf(image0.GetPixelSpan()); using (var image1 = Image.WrapMemory(mmg.Memory, image0.Width, image0.Height)) { diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestPatternProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestPatternProvider.cs index 9de791ab6d..71ae60fabc 100644 --- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestPatternProvider.cs +++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestPatternProvider.cs @@ -5,12 +5,11 @@ using System; using System.Collections.Generic; using System.Numerics; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; namespace SixLabors.ImageSharp.Tests { - using SixLabors.Memory; - public abstract partial class TestImageProvider where TPixel : struct, IPixel { diff --git a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs index f0daa0abb4..d06f5630f4 100644 --- a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs +++ b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs @@ -2,11 +2,12 @@ // Licensed under the Apache License, Version 2.0. using System; +using System.Buffers; using System.Drawing; using System.Drawing.Imaging; using SixLabors.ImageSharp.Advanced; -using SixLabors.Memory; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs @@ -43,7 +44,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs var image = new Image(w, h); - using (IBuffer workBuffer = Configuration.Default.MemoryAllocator.Allocate(w)) + using (IMemoryOwner workBuffer = Configuration.Default.MemoryAllocator.Allocate(w)) { fixed (Bgra32* destPtr = &workBuffer.GetReference()) { @@ -89,7 +90,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs var image = new Image(w, h); - using (IBuffer workBuffer = Configuration.Default.MemoryAllocator.Allocate(w)) + using (IMemoryOwner workBuffer = Configuration.Default.MemoryAllocator.Allocate(w)) { fixed (Bgr24* destPtr = &workBuffer.GetReference()) { @@ -122,7 +123,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs long destRowByteCount = data.Stride; long sourceRowByteCount = w * sizeof(Bgra32); - using (IBuffer workBuffer = image.GetConfiguration().MemoryAllocator.Allocate(w)) + using (IMemoryOwner workBuffer = image.GetConfiguration().MemoryAllocator.Allocate(w)) { fixed (Bgra32* sourcePtr = &workBuffer.GetReference()) { diff --git a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs index a1f97afb9c..6880486635 100644 --- a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs +++ b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs @@ -8,6 +8,7 @@ using System.Numerics; using SixLabors.ImageSharp.Advanced; using SixLabors.ImageSharp.Formats; +using SixLabors.ImageSharp.Memory; using SixLabors.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; diff --git a/tests/ImageSharp.Tests/TestUtilities/TestMemoryAllocator.cs b/tests/ImageSharp.Tests/TestUtilities/TestMemoryAllocator.cs new file mode 100644 index 0000000000..dc755e6827 --- /dev/null +++ b/tests/ImageSharp.Tests/TestUtilities/TestMemoryAllocator.cs @@ -0,0 +1,120 @@ +using System; +using System.Buffers; +using System.Runtime.InteropServices; + +using SixLabors.Memory; + +namespace SixLabors.ImageSharp.Tests.Memory +{ + internal class TestMemoryAllocator : MemoryAllocator + { + public TestMemoryAllocator(byte dirtyValue = 42) + { + this.DirtyValue = dirtyValue; + } + + /// + /// The value to initilazie the result buffer with, with non-clean options () + /// + public byte DirtyValue { get; } + + public override IMemoryOwner Allocate(int length, AllocationOptions options = AllocationOptions.None) + { + T[] array = this.AllocateArray(length, options); + + return new BasicArrayBuffer(array, length); + } + + public override IManagedByteBuffer AllocateManagedByteBuffer(int length, AllocationOptions options = AllocationOptions.None) + { + byte[] array = this.AllocateArray(length, options); + return new ManagedByteBuffer(array); + } + + private T[] AllocateArray(int length, AllocationOptions options) + where T : struct + { + var array = new T[length + 42]; + + if (options == AllocationOptions.None) + { + Span data = MemoryMarshal.Cast(array.AsSpan()); + data.Fill(this.DirtyValue); + } + + return array; + } + + /// + /// Wraps an array as an instance. + /// + private class BasicArrayBuffer : MemoryManager + where T : struct + { + private GCHandle pinHandle; + + /// + /// Initializes a new instance of the class + /// + /// The array + /// The length of the buffer + public BasicArrayBuffer(T[] array, int length) + { + DebugGuard.MustBeLessThanOrEqualTo(length, array.Length, nameof(length)); + this.Array = array; + this.Length = length; + } + + /// + /// Initializes a new instance of the class + /// + /// The array + public BasicArrayBuffer(T[] array) + : this(array, array.Length) + { + } + + /// + /// Gets the array + /// + public T[] Array { get; } + + /// + /// Gets the length + /// + public int Length { get; } + + /// + public override Span GetSpan() => this.Array.AsSpan(0, this.Length); + + public override unsafe MemoryHandle Pin(int elementIndex = 0) + { + if (!this.pinHandle.IsAllocated) + { + this.pinHandle = GCHandle.Alloc(this.Array, GCHandleType.Pinned); + } + + void* ptr = (void*)this.pinHandle.AddrOfPinnedObject(); + return new MemoryHandle(ptr, this.pinHandle); + } + + public override void Unpin() + { + throw new NotImplementedException(); + } + + /// + protected override void Dispose(bool disposing) + { + } + } + + private class ManagedByteBuffer : BasicArrayBuffer, IManagedByteBuffer + { + public ManagedByteBuffer(byte[] array) + : base(array) + { + } + } + } +} \ No newline at end of file diff --git a/tests/ImageSharp.Tests/TestUtilities/TestMemoryManager.cs b/tests/ImageSharp.Tests/TestUtilities/TestMemoryManager.cs index e7ecb2dda1..9274e5727c 100644 --- a/tests/ImageSharp.Tests/TestUtilities/TestMemoryManager.cs +++ b/tests/ImageSharp.Tests/TestUtilities/TestMemoryManager.cs @@ -3,22 +3,17 @@ using System.Buffers; namespace SixLabors.ImageSharp.Tests { - using SixLabors.ImageSharp.Advanced; - using SixLabors.ImageSharp.PixelFormats; - class TestMemoryManager : MemoryManager - where T : struct, IPixel + where T : struct { public TestMemoryManager(T[] pixelArray) { this.PixelArray = pixelArray; } - public T[] PixelArray { get; } + public T[] PixelArray { get; private set; } - protected override void Dispose(bool disposing) - { - } + public bool IsDisposed { get; private set; } public override Span GetSpan() { @@ -35,16 +30,17 @@ namespace SixLabors.ImageSharp.Tests throw new NotImplementedException(); } - public static TestMemoryManager CreateAsCopyOfPixelData(Span pixelData) + public static TestMemoryManager CreateAsCopyOf(Span copyThisBuffer) { - var pixelArray = new T[pixelData.Length]; - pixelData.CopyTo(pixelArray); + var pixelArray = new T[copyThisBuffer.Length]; + copyThisBuffer.CopyTo(pixelArray); return new TestMemoryManager(pixelArray); } - public static TestMemoryManager CreateAsCopyOfPixelData(Image image) + protected override void Dispose(bool disposing) { - return CreateAsCopyOfPixelData(image.GetPixelSpan()); + this.IsDisposed = true; + this.PixelArray = null; } } } \ No newline at end of file diff --git a/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs b/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs index 03ab422e56..5a14f2e26e 100644 --- a/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs +++ b/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs @@ -6,7 +6,8 @@ using System.Collections.Generic; using System.Globalization; using System.Linq; using System.Reflection; - +using SixLabors.ImageSharp.Advanced; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison; @@ -14,9 +15,6 @@ using SixLabors.Primitives; namespace SixLabors.ImageSharp.Tests { - using SixLabors.ImageSharp.Advanced; - using SixLabors.Memory; - /// /// Various utility and extension methods. /// @@ -214,7 +212,7 @@ namespace SixLabors.ImageSharp.Tests using (Image image0 = provider.GetImage()) { - var mmg = TestMemoryManager.CreateAsCopyOfPixelData(image0.GetPixelSpan()); + var mmg = TestMemoryManager.CreateAsCopyOf(image0.GetPixelSpan()); using (var image1 = Image.WrapMemory(mmg.Memory, image0.Width, image0.Height)) { @@ -228,6 +226,8 @@ namespace SixLabors.ImageSharp.Tests // TODO: Investigate the cause of pixel inaccuracies under Linux if (TestEnvironment.IsWindows) { + string testNameBackup = provider.Utility.TestName; + if (useReferenceOutputFrom != null) { provider.Utility.TestName = useReferenceOutputFrom; @@ -239,6 +239,8 @@ namespace SixLabors.ImageSharp.Tests testOutputDetails, appendPixelTypeToFileName: appendPixelTypeToFileName, appendSourceFileOrDescription: appendSourceFileOrDescription); + + provider.Utility.TestName = testNameBackup; } } } diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs index 02acdfa183..5305eb2ba3 100644 --- a/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs +++ b/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs @@ -10,6 +10,7 @@ using System.Collections.Concurrent; using System.IO; using SixLabors.ImageSharp.Formats; +using SixLabors.ImageSharp.Memory; namespace SixLabors.ImageSharp.Tests { diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/TestUtilityExtensionsTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/TestUtilityExtensionsTests.cs index 6e8278276c..655f5b032c 100644 --- a/tests/ImageSharp.Tests/TestUtilities/Tests/TestUtilityExtensionsTests.cs +++ b/tests/ImageSharp.Tests/TestUtilities/Tests/TestUtilityExtensionsTests.cs @@ -6,9 +6,9 @@ using System.Collections.Generic; using System.Linq; using System.Numerics; +using SixLabors.ImageSharp.Memory; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; -using SixLabors.Memory; using Xunit; using Xunit.Abstractions;