mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
6 years ago
768 changed files with 18808 additions and 14321 deletions
@ -1 +1 @@ |
|||||
Subproject commit 36b2d55f5bb0d91024955bd26ba220ee41cc96e5 |
Subproject commit ea561c249ba86352fe3b69e612b8072f3652eacb |
||||
@ -0,0 +1,19 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Advanced |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Defines the contract for an action that operates on a row interval.
|
||||
|
/// </summary>
|
||||
|
public interface IRowIntervalOperation |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Invokes the method passing the row interval.
|
||||
|
/// </summary>
|
||||
|
/// <param name="rows">The row interval.</param>
|
||||
|
void Invoke(in RowInterval rows); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,23 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
using System; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Advanced |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Defines the contract for an action that operates on a row interval with a temporary buffer.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
|
||||
|
public interface IRowIntervalOperation<TBuffer> |
||||
|
where TBuffer : unmanaged |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Invokes the method passing the row interval and a buffer.
|
||||
|
/// </summary>
|
||||
|
/// <param name="rows">The row interval.</param>
|
||||
|
/// <param name="span">The contiguous region of memory.</param>
|
||||
|
void Invoke(in RowInterval rows, Span<TBuffer> span); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,17 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Advanced |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Defines the contract for an action that operates on a row.
|
||||
|
/// </summary>
|
||||
|
public interface IRowOperation |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Invokes the method passing the row y coordinate.
|
||||
|
/// </summary>
|
||||
|
/// <param name="y">The row y coordinate.</param>
|
||||
|
void Invoke(int y); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,22 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
using System; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Advanced |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Defines the contract for an action that operates on a row with a temporary buffer.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
|
||||
|
public interface IRowOperation<TBuffer> |
||||
|
where TBuffer : unmanaged |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Invokes the method passing the row and a buffer.
|
||||
|
/// </summary>
|
||||
|
/// <param name="y">The row y coordinate.</param>
|
||||
|
/// <param name="span">The contiguous region of memory.</param>
|
||||
|
void Invoke(int y, Span<TBuffer> span); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,198 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Buffers; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using System.Threading.Tasks; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Advanced |
||||
|
{ |
||||
|
/// <content>
|
||||
|
/// Utility methods for batched processing of pixel row intervals.
|
||||
|
/// Parallel execution is optimized for image processing based on values defined
|
||||
|
/// <see cref="ParallelExecutionSettings"/> or <see cref="Configuration"/>.
|
||||
|
/// Using this class is preferred over direct usage of <see cref="Parallel"/> utility methods.
|
||||
|
/// </content>
|
||||
|
public static partial class ParallelRowIterator |
||||
|
{ |
||||
|
private readonly struct RowOperationWrapper<T> |
||||
|
where T : struct, IRowOperation |
||||
|
{ |
||||
|
private readonly int minY; |
||||
|
private readonly int maxY; |
||||
|
private readonly int stepY; |
||||
|
private readonly T action; |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public RowOperationWrapper( |
||||
|
int minY, |
||||
|
int maxY, |
||||
|
int stepY, |
||||
|
in T action) |
||||
|
{ |
||||
|
this.minY = minY; |
||||
|
this.maxY = maxY; |
||||
|
this.stepY = stepY; |
||||
|
this.action = action; |
||||
|
} |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public void Invoke(int i) |
||||
|
{ |
||||
|
int yMin = this.minY + (i * this.stepY); |
||||
|
|
||||
|
if (yMin >= this.maxY) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int yMax = Math.Min(yMin + this.stepY, this.maxY); |
||||
|
|
||||
|
for (int y = yMin; y < yMax; y++) |
||||
|
{ |
||||
|
// Skip the safety copy when invoking a potentially impure method on a readonly field
|
||||
|
Unsafe.AsRef(this.action).Invoke(y); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private readonly struct RowOperationWrapper<T, TBuffer> |
||||
|
where T : struct, IRowOperation<TBuffer> |
||||
|
where TBuffer : unmanaged |
||||
|
{ |
||||
|
private readonly int minY; |
||||
|
private readonly int maxY; |
||||
|
private readonly int stepY; |
||||
|
private readonly int width; |
||||
|
private readonly MemoryAllocator allocator; |
||||
|
private readonly T action; |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public RowOperationWrapper( |
||||
|
int minY, |
||||
|
int maxY, |
||||
|
int stepY, |
||||
|
int width, |
||||
|
MemoryAllocator allocator, |
||||
|
in T action) |
||||
|
{ |
||||
|
this.minY = minY; |
||||
|
this.maxY = maxY; |
||||
|
this.stepY = stepY; |
||||
|
this.width = width; |
||||
|
this.allocator = allocator; |
||||
|
this.action = action; |
||||
|
} |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public void Invoke(int i) |
||||
|
{ |
||||
|
int yMin = this.minY + (i * this.stepY); |
||||
|
|
||||
|
if (yMin >= this.maxY) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int yMax = Math.Min(yMin + this.stepY, this.maxY); |
||||
|
|
||||
|
using IMemoryOwner<TBuffer> buffer = this.allocator.Allocate<TBuffer>(this.width); |
||||
|
|
||||
|
Span<TBuffer> span = buffer.Memory.Span; |
||||
|
|
||||
|
for (int y = yMin; y < yMax; y++) |
||||
|
{ |
||||
|
Unsafe.AsRef(this.action).Invoke(y, span); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private readonly struct RowIntervalOperationWrapper<T> |
||||
|
where T : struct, IRowIntervalOperation |
||||
|
{ |
||||
|
private readonly int minY; |
||||
|
private readonly int maxY; |
||||
|
private readonly int stepY; |
||||
|
private readonly T operation; |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public RowIntervalOperationWrapper( |
||||
|
int minY, |
||||
|
int maxY, |
||||
|
int stepY, |
||||
|
in T operation) |
||||
|
{ |
||||
|
this.minY = minY; |
||||
|
this.maxY = maxY; |
||||
|
this.stepY = stepY; |
||||
|
this.operation = operation; |
||||
|
} |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public void Invoke(int i) |
||||
|
{ |
||||
|
int yMin = this.minY + (i * this.stepY); |
||||
|
|
||||
|
if (yMin >= this.maxY) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int yMax = Math.Min(yMin + this.stepY, this.maxY); |
||||
|
var rows = new RowInterval(yMin, yMax); |
||||
|
|
||||
|
// Skip the safety copy when invoking a potentially impure method on a readonly field
|
||||
|
Unsafe.AsRef(in this.operation).Invoke(in rows); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private readonly struct RowIntervalOperationWrapper<T, TBuffer> |
||||
|
where T : struct, IRowIntervalOperation<TBuffer> |
||||
|
where TBuffer : unmanaged |
||||
|
{ |
||||
|
private readonly int minY; |
||||
|
private readonly int maxY; |
||||
|
private readonly int stepY; |
||||
|
private readonly int width; |
||||
|
private readonly MemoryAllocator allocator; |
||||
|
private readonly T operation; |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public RowIntervalOperationWrapper( |
||||
|
int minY, |
||||
|
int maxY, |
||||
|
int stepY, |
||||
|
int width, |
||||
|
MemoryAllocator allocator, |
||||
|
in T operation) |
||||
|
{ |
||||
|
this.minY = minY; |
||||
|
this.maxY = maxY; |
||||
|
this.stepY = stepY; |
||||
|
this.width = width; |
||||
|
this.allocator = allocator; |
||||
|
this.operation = operation; |
||||
|
} |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public void Invoke(int i) |
||||
|
{ |
||||
|
int yMin = this.minY + (i * this.stepY); |
||||
|
|
||||
|
if (yMin >= this.maxY) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int yMax = Math.Min(yMin + this.stepY, this.maxY); |
||||
|
var rows = new RowInterval(yMin, yMax); |
||||
|
|
||||
|
using IMemoryOwner<TBuffer> buffer = this.allocator.Allocate<TBuffer>(this.width); |
||||
|
|
||||
|
Unsafe.AsRef(in this.operation).Invoke(in rows, buffer.Memory.Span); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,288 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Buffers; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using System.Threading.Tasks; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Advanced |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Utility methods for batched processing of pixel row intervals.
|
||||
|
/// Parallel execution is optimized for image processing based on values defined
|
||||
|
/// <see cref="ParallelExecutionSettings"/> or <see cref="Configuration"/>.
|
||||
|
/// Using this class is preferred over direct usage of <see cref="Parallel"/> utility methods.
|
||||
|
/// </summary>
|
||||
|
public static partial class ParallelRowIterator |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Iterate through the rows of a rectangle in optimized batches.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="T">The type of row operation to perform.</typeparam>
|
||||
|
/// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
|
||||
|
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
||||
|
/// <param name="operation">The operation defining the iteration logic on a single row.</param>
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public static void IterateRows<T>(Configuration configuration, Rectangle rectangle, in T operation) |
||||
|
where T : struct, IRowOperation |
||||
|
{ |
||||
|
var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration); |
||||
|
IterateRows(rectangle, in parallelSettings, in operation); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Iterate through the rows of a rectangle in optimized batches.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="T">The type of row operation to perform.</typeparam>
|
||||
|
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
||||
|
/// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
|
||||
|
/// <param name="operation">The operation defining the iteration logic on a single row.</param>
|
||||
|
public static void IterateRows<T>( |
||||
|
Rectangle rectangle, |
||||
|
in ParallelExecutionSettings parallelSettings, |
||||
|
in T operation) |
||||
|
where T : struct, IRowOperation |
||||
|
{ |
||||
|
ValidateRectangle(rectangle); |
||||
|
|
||||
|
int top = rectangle.Top; |
||||
|
int bottom = rectangle.Bottom; |
||||
|
int width = rectangle.Width; |
||||
|
int height = rectangle.Height; |
||||
|
|
||||
|
int maxSteps = DivideCeil(width * height, parallelSettings.MinimumPixelsProcessedPerTask); |
||||
|
int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps); |
||||
|
|
||||
|
// Avoid TPL overhead in this trivial case:
|
||||
|
if (numOfSteps == 1) |
||||
|
{ |
||||
|
for (int y = top; y < bottom; y++) |
||||
|
{ |
||||
|
Unsafe.AsRef(operation).Invoke(y); |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int verticalStep = DivideCeil(rectangle.Height, numOfSteps); |
||||
|
var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps }; |
||||
|
var wrappingOperation = new RowOperationWrapper<T>(top, bottom, verticalStep, in operation); |
||||
|
|
||||
|
Parallel.For( |
||||
|
0, |
||||
|
numOfSteps, |
||||
|
parallelOptions, |
||||
|
wrappingOperation.Invoke); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Iterate through the rows of a rectangle in optimized batches.
|
||||
|
/// instantiating a temporary buffer for each <paramref name="operation"/> invocation.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="T">The type of row operation to perform.</typeparam>
|
||||
|
/// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
|
||||
|
/// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
|
||||
|
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
||||
|
/// <param name="operation">The operation defining the iteration logic on a single row.</param>
|
||||
|
public static void IterateRows<T, TBuffer>(Configuration configuration, Rectangle rectangle, in T operation) |
||||
|
where T : struct, IRowOperation<TBuffer> |
||||
|
where TBuffer : unmanaged |
||||
|
{ |
||||
|
var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration); |
||||
|
IterateRows<T, TBuffer>(rectangle, in parallelSettings, in operation); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Iterate through the rows of a rectangle in optimized batches.
|
||||
|
/// instantiating a temporary buffer for each <paramref name="operation"/> invocation.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="T">The type of row operation to perform.</typeparam>
|
||||
|
/// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
|
||||
|
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
||||
|
/// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
|
||||
|
/// <param name="operation">The operation defining the iteration logic on a single row.</param>
|
||||
|
public static void IterateRows<T, TBuffer>( |
||||
|
Rectangle rectangle, |
||||
|
in ParallelExecutionSettings parallelSettings, |
||||
|
in T operation) |
||||
|
where T : struct, IRowOperation<TBuffer> |
||||
|
where TBuffer : unmanaged |
||||
|
{ |
||||
|
ValidateRectangle(rectangle); |
||||
|
|
||||
|
int top = rectangle.Top; |
||||
|
int bottom = rectangle.Bottom; |
||||
|
int width = rectangle.Width; |
||||
|
int height = rectangle.Height; |
||||
|
|
||||
|
int maxSteps = DivideCeil(width * height, parallelSettings.MinimumPixelsProcessedPerTask); |
||||
|
int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps); |
||||
|
MemoryAllocator allocator = parallelSettings.MemoryAllocator; |
||||
|
|
||||
|
// Avoid TPL overhead in this trivial case:
|
||||
|
if (numOfSteps == 1) |
||||
|
{ |
||||
|
using IMemoryOwner<TBuffer> buffer = allocator.Allocate<TBuffer>(width); |
||||
|
Span<TBuffer> span = buffer.Memory.Span; |
||||
|
|
||||
|
for (int y = top; y < bottom; y++) |
||||
|
{ |
||||
|
Unsafe.AsRef(operation).Invoke(y, span); |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int verticalStep = DivideCeil(height, numOfSteps); |
||||
|
var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps }; |
||||
|
var wrappingOperation = new RowOperationWrapper<T, TBuffer>(top, bottom, verticalStep, width, allocator, in operation); |
||||
|
|
||||
|
Parallel.For( |
||||
|
0, |
||||
|
numOfSteps, |
||||
|
parallelOptions, |
||||
|
wrappingOperation.Invoke); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="T">The type of row operation to perform.</typeparam>
|
||||
|
/// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
|
||||
|
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
||||
|
/// <param name="operation">The operation defining the iteration logic on a single <see cref="RowInterval"/>.</param>
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public static void IterateRowIntervals<T>(Configuration configuration, Rectangle rectangle, in T operation) |
||||
|
where T : struct, IRowIntervalOperation |
||||
|
{ |
||||
|
var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration); |
||||
|
IterateRowIntervals(rectangle, in parallelSettings, in operation); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="T">The type of row operation to perform.</typeparam>
|
||||
|
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
||||
|
/// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
|
||||
|
/// <param name="operation">The operation defining the iteration logic on a single <see cref="RowInterval"/>.</param>
|
||||
|
public static void IterateRowIntervals<T>( |
||||
|
Rectangle rectangle, |
||||
|
in ParallelExecutionSettings parallelSettings, |
||||
|
in T operation) |
||||
|
where T : struct, IRowIntervalOperation |
||||
|
{ |
||||
|
ValidateRectangle(rectangle); |
||||
|
|
||||
|
int top = rectangle.Top; |
||||
|
int bottom = rectangle.Bottom; |
||||
|
int width = rectangle.Width; |
||||
|
int height = rectangle.Height; |
||||
|
|
||||
|
int maxSteps = DivideCeil(width * height, parallelSettings.MinimumPixelsProcessedPerTask); |
||||
|
int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps); |
||||
|
|
||||
|
// Avoid TPL overhead in this trivial case:
|
||||
|
if (numOfSteps == 1) |
||||
|
{ |
||||
|
var rows = new RowInterval(top, bottom); |
||||
|
Unsafe.AsRef(in operation).Invoke(in rows); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int verticalStep = DivideCeil(rectangle.Height, numOfSteps); |
||||
|
var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps }; |
||||
|
var wrappingOperation = new RowIntervalOperationWrapper<T>(top, bottom, verticalStep, in operation); |
||||
|
|
||||
|
Parallel.For( |
||||
|
0, |
||||
|
numOfSteps, |
||||
|
parallelOptions, |
||||
|
wrappingOperation.Invoke); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s
|
||||
|
/// instantiating a temporary buffer for each <paramref name="operation"/> invocation.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="T">The type of row operation to perform.</typeparam>
|
||||
|
/// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
|
||||
|
/// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
|
||||
|
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
||||
|
/// <param name="operation">The operation defining the iteration logic on a single <see cref="RowInterval"/>.</param>
|
||||
|
public static void IterateRowIntervals<T, TBuffer>(Configuration configuration, Rectangle rectangle, in T operation) |
||||
|
where T : struct, IRowIntervalOperation<TBuffer> |
||||
|
where TBuffer : unmanaged |
||||
|
{ |
||||
|
var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration); |
||||
|
IterateRowIntervals<T, TBuffer>(rectangle, in parallelSettings, in operation); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s
|
||||
|
/// instantiating a temporary buffer for each <paramref name="operation"/> invocation.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="T">The type of row operation to perform.</typeparam>
|
||||
|
/// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
|
||||
|
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
||||
|
/// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
|
||||
|
/// <param name="operation">The operation defining the iteration logic on a single <see cref="RowInterval"/>.</param>
|
||||
|
public static void IterateRowIntervals<T, TBuffer>( |
||||
|
Rectangle rectangle, |
||||
|
in ParallelExecutionSettings parallelSettings, |
||||
|
in T operation) |
||||
|
where T : struct, IRowIntervalOperation<TBuffer> |
||||
|
where TBuffer : unmanaged |
||||
|
{ |
||||
|
ValidateRectangle(rectangle); |
||||
|
|
||||
|
int top = rectangle.Top; |
||||
|
int bottom = rectangle.Bottom; |
||||
|
int width = rectangle.Width; |
||||
|
int height = rectangle.Height; |
||||
|
|
||||
|
int maxSteps = DivideCeil(width * height, parallelSettings.MinimumPixelsProcessedPerTask); |
||||
|
int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps); |
||||
|
MemoryAllocator allocator = parallelSettings.MemoryAllocator; |
||||
|
|
||||
|
// Avoid TPL overhead in this trivial case:
|
||||
|
if (numOfSteps == 1) |
||||
|
{ |
||||
|
var rows = new RowInterval(top, bottom); |
||||
|
using IMemoryOwner<TBuffer> buffer = allocator.Allocate<TBuffer>(width); |
||||
|
|
||||
|
Unsafe.AsRef(operation).Invoke(in rows, buffer.Memory.Span); |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int verticalStep = DivideCeil(height, numOfSteps); |
||||
|
var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps }; |
||||
|
var wrappingOperation = new RowIntervalOperationWrapper<T, TBuffer>(top, bottom, verticalStep, width, allocator, in operation); |
||||
|
|
||||
|
Parallel.For( |
||||
|
0, |
||||
|
numOfSteps, |
||||
|
parallelOptions, |
||||
|
wrappingOperation.Invoke); |
||||
|
} |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
private static int DivideCeil(int dividend, int divisor) => 1 + ((dividend - 1) / divisor); |
||||
|
|
||||
|
private static void ValidateRectangle(Rectangle rectangle) |
||||
|
{ |
||||
|
Guard.MustBeGreaterThan( |
||||
|
rectangle.Width, |
||||
|
0, |
||||
|
$"{nameof(rectangle)}.{nameof(rectangle.Width)}"); |
||||
|
|
||||
|
Guard.MustBeGreaterThan( |
||||
|
rectangle.Height, |
||||
|
0, |
||||
|
$"{nameof(rectangle)}.{nameof(rectangle.Height)}"); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,160 +0,0 @@ |
|||||
// Copyright (c) Six Labors and contributors.
|
|
||||
// Licensed under the Apache License, Version 2.0.
|
|
||||
|
|
||||
using System; |
|
||||
using System.Buffers; |
|
||||
using System.Runtime.CompilerServices; |
|
||||
using System.Threading.Tasks; |
|
||||
|
|
||||
using SixLabors.ImageSharp.Memory; |
|
||||
|
|
||||
namespace SixLabors.ImageSharp.Advanced.ParallelUtils |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Utility methods for batched processing of pixel row intervals.
|
|
||||
/// Parallel execution is optimized for image processing based on values defined
|
|
||||
/// <see cref="ParallelExecutionSettings"/> or <see cref="Configuration"/>.
|
|
||||
/// Using this class is preferred over direct usage of <see cref="Parallel"/> utility methods.
|
|
||||
/// </summary>
|
|
||||
public static class ParallelHelper |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s.
|
|
||||
/// </summary>
|
|
||||
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
|
||||
/// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
|
|
||||
/// <param name="body">The method body defining the iteration logic on a single <see cref="RowInterval"/>.</param>
|
|
||||
public static void IterateRows(Rectangle rectangle, Configuration configuration, Action<RowInterval> body) |
|
||||
{ |
|
||||
ParallelExecutionSettings parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration); |
|
||||
|
|
||||
IterateRows(rectangle, parallelSettings, body); |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s.
|
|
||||
/// </summary>
|
|
||||
/// <param name="rectangle">The <see cref="Rectangle"/>.</param>
|
|
||||
/// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
|
|
||||
/// <param name="body">The method body defining the iteration logic on a single <see cref="RowInterval"/>.</param>
|
|
||||
public static void IterateRows( |
|
||||
Rectangle rectangle, |
|
||||
in ParallelExecutionSettings parallelSettings, |
|
||||
Action<RowInterval> body) |
|
||||
{ |
|
||||
ValidateRectangle(rectangle); |
|
||||
|
|
||||
int maxSteps = DivideCeil( |
|
||||
rectangle.Width * rectangle.Height, |
|
||||
parallelSettings.MinimumPixelsProcessedPerTask); |
|
||||
|
|
||||
int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps); |
|
||||
|
|
||||
// Avoid TPL overhead in this trivial case:
|
|
||||
if (numOfSteps == 1) |
|
||||
{ |
|
||||
var rows = new RowInterval(rectangle.Top, rectangle.Bottom); |
|
||||
body(rows); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
int verticalStep = DivideCeil(rectangle.Height, numOfSteps); |
|
||||
|
|
||||
var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps }; |
|
||||
|
|
||||
Parallel.For( |
|
||||
0, |
|
||||
numOfSteps, |
|
||||
parallelOptions, |
|
||||
i => |
|
||||
{ |
|
||||
int yMin = rectangle.Top + (i * verticalStep); |
|
||||
int yMax = Math.Min(yMin + verticalStep, rectangle.Bottom); |
|
||||
|
|
||||
var rows = new RowInterval(yMin, yMax); |
|
||||
body(rows); |
|
||||
}); |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s
|
|
||||
/// instantiating a temporary buffer for each <paramref name="body"/> invocation.
|
|
||||
/// </summary>
|
|
||||
internal static void IterateRowsWithTempBuffer<T>( |
|
||||
Rectangle rectangle, |
|
||||
in ParallelExecutionSettings parallelSettings, |
|
||||
Action<RowInterval, Memory<T>> body) |
|
||||
where T : unmanaged |
|
||||
{ |
|
||||
ValidateRectangle(rectangle); |
|
||||
|
|
||||
int maxSteps = DivideCeil(rectangle.Width * rectangle.Height, parallelSettings.MinimumPixelsProcessedPerTask); |
|
||||
|
|
||||
int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps); |
|
||||
|
|
||||
MemoryAllocator memoryAllocator = parallelSettings.MemoryAllocator; |
|
||||
|
|
||||
// Avoid TPL overhead in this trivial case:
|
|
||||
if (numOfSteps == 1) |
|
||||
{ |
|
||||
var rows = new RowInterval(rectangle.Top, rectangle.Bottom); |
|
||||
using (IMemoryOwner<T> buffer = memoryAllocator.Allocate<T>(rectangle.Width)) |
|
||||
{ |
|
||||
body(rows, buffer.Memory); |
|
||||
} |
|
||||
|
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
int verticalStep = DivideCeil(rectangle.Height, numOfSteps); |
|
||||
|
|
||||
var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps }; |
|
||||
|
|
||||
Parallel.For( |
|
||||
0, |
|
||||
numOfSteps, |
|
||||
parallelOptions, |
|
||||
i => |
|
||||
{ |
|
||||
int yMin = rectangle.Top + (i * verticalStep); |
|
||||
int yMax = Math.Min(yMin + verticalStep, rectangle.Bottom); |
|
||||
|
|
||||
var rows = new RowInterval(yMin, yMax); |
|
||||
|
|
||||
using (IMemoryOwner<T> buffer = memoryAllocator.Allocate<T>(rectangle.Width)) |
|
||||
{ |
|
||||
body(rows, buffer.Memory); |
|
||||
} |
|
||||
}); |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s
|
|
||||
/// instantiating a temporary buffer for each <paramref name="body"/> invocation.
|
|
||||
/// </summary>
|
|
||||
internal static void IterateRowsWithTempBuffer<T>( |
|
||||
Rectangle rectangle, |
|
||||
Configuration configuration, |
|
||||
Action<RowInterval, Memory<T>> body) |
|
||||
where T : unmanaged |
|
||||
{ |
|
||||
IterateRowsWithTempBuffer(rectangle, ParallelExecutionSettings.FromConfiguration(configuration), body); |
|
||||
} |
|
||||
|
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|
||||
private static int DivideCeil(int dividend, int divisor) => 1 + ((dividend - 1) / divisor); |
|
||||
|
|
||||
private static void ValidateRectangle(Rectangle rectangle) |
|
||||
{ |
|
||||
Guard.MustBeGreaterThan( |
|
||||
rectangle.Width, |
|
||||
0, |
|
||||
$"{nameof(rectangle)}.{nameof(rectangle.Width)}"); |
|
||||
|
|
||||
Guard.MustBeGreaterThan( |
|
||||
rectangle.Height, |
|
||||
0, |
|
||||
$"{nameof(rectangle)}.{nameof(rectangle.Height)}"); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,29 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Reflection; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using SixLabors.ImageSharp; |
||||
|
|
||||
|
namespace SixLabors |
||||
|
{ |
||||
|
internal static partial class Guard |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Ensures that the value is a value type.
|
||||
|
/// </summary>
|
||||
|
/// <param name="value">The target object, which cannot be null.</param>
|
||||
|
/// <param name="parameterName">The name of the parameter that is to be checked.</param>
|
||||
|
/// <typeparam name="TValue">The type of the value.</typeparam>
|
||||
|
/// <exception cref="ArgumentException"><paramref name="value"/> is not a value type.</exception>
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public static void MustBeValueType<TValue>(TValue value, string parameterName) |
||||
|
{ |
||||
|
if (!value.GetType().GetTypeInfo().IsValueType) |
||||
|
{ |
||||
|
ThrowHelper.ThrowArgumentException("Type must be a struct.", parameterName); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,103 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
#if SUPPORTS_RUNTIME_INTRINSICS
|
||||
|
|
||||
|
using System; |
||||
|
using System.Numerics; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using System.Runtime.InteropServices; |
||||
|
using System.Runtime.Intrinsics; |
||||
|
using System.Runtime.Intrinsics.X86; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp |
||||
|
{ |
||||
|
internal static partial class SimdUtils |
||||
|
{ |
||||
|
public static class Avx2Intrinsics |
||||
|
{ |
||||
|
private static ReadOnlySpan<byte> PermuteMaskDeinterleave8x32 => new byte[] { 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 7, 0, 0, 0 }; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// <see cref="NormalizedFloatToByteSaturate"/> as many elements as possible, slicing them down (keeping the remainder).
|
||||
|
/// </summary>
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
internal static void NormalizedFloatToByteSaturateReduce( |
||||
|
ref ReadOnlySpan<float> source, |
||||
|
ref Span<byte> dest) |
||||
|
{ |
||||
|
DebugGuard.IsTrue(source.Length == dest.Length, nameof(source), "Input spans must be of same length!"); |
||||
|
|
||||
|
if (Avx2.IsSupported) |
||||
|
{ |
||||
|
int remainder = ImageMaths.ModuloP2(source.Length, Vector<byte>.Count); |
||||
|
int adjustedCount = source.Length - remainder; |
||||
|
|
||||
|
if (adjustedCount > 0) |
||||
|
{ |
||||
|
NormalizedFloatToByteSaturate( |
||||
|
source.Slice(0, adjustedCount), |
||||
|
dest.Slice(0, adjustedCount)); |
||||
|
|
||||
|
source = source.Slice(adjustedCount); |
||||
|
dest = dest.Slice(adjustedCount); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Implementation of <see cref="SimdUtils.NormalizedFloatToByteSaturate"/>, which is faster on new .NET runtime.
|
||||
|
/// </summary>
|
||||
|
/// <remarks>
|
||||
|
/// Implementation is based on MagicScaler code:
|
||||
|
/// https://github.com/saucecontrol/PhotoSauce/blob/a9bd6e5162d2160419f0cf743fd4f536c079170b/src/MagicScaler/Magic/Processors/ConvertersFloat.cs#L453-L477
|
||||
|
/// </remarks>
|
||||
|
internal static void NormalizedFloatToByteSaturate( |
||||
|
ReadOnlySpan<float> source, |
||||
|
Span<byte> dest) |
||||
|
{ |
||||
|
VerifySpanInput(source, dest, Vector256<byte>.Count); |
||||
|
|
||||
|
int n = dest.Length / Vector256<byte>.Count; |
||||
|
|
||||
|
ref Vector256<float> sourceBase = |
||||
|
ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(source)); |
||||
|
ref Vector256<byte> destBase = ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(dest)); |
||||
|
|
||||
|
var maxBytes = Vector256.Create(255f); |
||||
|
ref byte maskBase = ref MemoryMarshal.GetReference(PermuteMaskDeinterleave8x32); |
||||
|
Vector256<int> mask = Unsafe.As<byte, Vector256<int>>(ref maskBase); |
||||
|
|
||||
|
for (int i = 0; i < n; i++) |
||||
|
{ |
||||
|
ref Vector256<float> s = ref Unsafe.Add(ref sourceBase, i * 4); |
||||
|
|
||||
|
Vector256<float> f0 = s; |
||||
|
Vector256<float> f1 = Unsafe.Add(ref s, 1); |
||||
|
Vector256<float> f2 = Unsafe.Add(ref s, 2); |
||||
|
Vector256<float> f3 = Unsafe.Add(ref s, 3); |
||||
|
|
||||
|
Vector256<int> w0 = ConvertToInt32(f0, maxBytes); |
||||
|
Vector256<int> w1 = ConvertToInt32(f1, maxBytes); |
||||
|
Vector256<int> w2 = ConvertToInt32(f2, maxBytes); |
||||
|
Vector256<int> w3 = ConvertToInt32(f3, maxBytes); |
||||
|
|
||||
|
Vector256<short> u0 = Avx2.PackSignedSaturate(w0, w1); |
||||
|
Vector256<short> u1 = Avx2.PackSignedSaturate(w2, w3); |
||||
|
Vector256<byte> b = Avx2.PackUnsignedSaturate(u0, u1); |
||||
|
b = Avx2.PermuteVar8x32(b.AsInt32(), mask).AsByte(); |
||||
|
|
||||
|
Unsafe.Add(ref destBase, i) = b; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector256<int> ConvertToInt32(Vector256<float> vf, Vector256<float> scale) |
||||
|
{ |
||||
|
vf = Avx.Multiply(vf, scale); |
||||
|
return Avx.ConvertToVector256Int32(vf); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
#endif
|
||||
@ -1,112 +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.Tuples |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Contains 8 element value tuples of various types.
|
|
||||
/// </summary>
|
|
||||
internal static class Octet |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Value tuple of <see cref="uint"/>-s.
|
|
||||
/// </summary>
|
|
||||
[StructLayout(LayoutKind.Explicit, Size = 8 * sizeof(uint))] |
|
||||
public struct OfUInt32 |
|
||||
{ |
|
||||
[FieldOffset(0 * sizeof(uint))] |
|
||||
public uint V0; |
|
||||
|
|
||||
[FieldOffset(1 * sizeof(uint))] |
|
||||
public uint V1; |
|
||||
|
|
||||
[FieldOffset(2 * sizeof(uint))] |
|
||||
public uint V2; |
|
||||
|
|
||||
[FieldOffset(3 * sizeof(uint))] |
|
||||
public uint V3; |
|
||||
|
|
||||
[FieldOffset(4 * sizeof(uint))] |
|
||||
public uint V4; |
|
||||
|
|
||||
[FieldOffset(5 * sizeof(uint))] |
|
||||
public uint V5; |
|
||||
|
|
||||
[FieldOffset(6 * sizeof(uint))] |
|
||||
public uint V6; |
|
||||
|
|
||||
[FieldOffset(7 * sizeof(uint))] |
|
||||
public uint V7; |
|
||||
|
|
||||
public override string ToString() |
|
||||
{ |
|
||||
return $"{nameof(Octet)}.{nameof(OfUInt32)}({this.V0},{this.V1},{this.V2},{this.V3},{this.V4},{this.V5},{this.V6},{this.V7})"; |
|
||||
} |
|
||||
|
|
||||
[MethodImpl(InliningOptions.ShortMethod)] |
|
||||
public void LoadFrom(ref OfByte src) |
|
||||
{ |
|
||||
this.V0 = src.V0; |
|
||||
this.V1 = src.V1; |
|
||||
this.V2 = src.V2; |
|
||||
this.V3 = src.V3; |
|
||||
this.V4 = src.V4; |
|
||||
this.V5 = src.V5; |
|
||||
this.V6 = src.V6; |
|
||||
this.V7 = src.V7; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Value tuple of <see cref="byte"/>-s
|
|
||||
/// </summary>
|
|
||||
[StructLayout(LayoutKind.Explicit, Size = 8)] |
|
||||
public struct OfByte |
|
||||
{ |
|
||||
[FieldOffset(0)] |
|
||||
public byte V0; |
|
||||
|
|
||||
[FieldOffset(1)] |
|
||||
public byte V1; |
|
||||
|
|
||||
[FieldOffset(2)] |
|
||||
public byte V2; |
|
||||
|
|
||||
[FieldOffset(3)] |
|
||||
public byte V3; |
|
||||
|
|
||||
[FieldOffset(4)] |
|
||||
public byte V4; |
|
||||
|
|
||||
[FieldOffset(5)] |
|
||||
public byte V5; |
|
||||
|
|
||||
[FieldOffset(6)] |
|
||||
public byte V6; |
|
||||
|
|
||||
[FieldOffset(7)] |
|
||||
public byte V7; |
|
||||
|
|
||||
public override string ToString() |
|
||||
{ |
|
||||
return $"{nameof(Octet)}.{nameof(OfByte)}({this.V0},{this.V1},{this.V2},{this.V3},{this.V4},{this.V5},{this.V6},{this.V7})"; |
|
||||
} |
|
||||
|
|
||||
[MethodImpl(InliningOptions.ShortMethod)] |
|
||||
public void LoadFrom(ref OfUInt32 src) |
|
||||
{ |
|
||||
this.V0 = (byte)src.V0; |
|
||||
this.V1 = (byte)src.V1; |
|
||||
this.V2 = (byte)src.V2; |
|
||||
this.V3 = (byte)src.V3; |
|
||||
this.V4 = (byte)src.V4; |
|
||||
this.V5 = (byte)src.V5; |
|
||||
this.V6 = (byte)src.V6; |
|
||||
this.V7 = (byte)src.V7; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,73 @@ |
|||||
|
// 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.Tuples |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Contains 8 element value tuples of various types.
|
||||
|
/// </summary>
|
||||
|
[StructLayout(LayoutKind.Sequential)] |
||||
|
internal struct Octet<T> |
||||
|
where T : unmanaged |
||||
|
{ |
||||
|
public T V0; |
||||
|
public T V1; |
||||
|
public T V2; |
||||
|
public T V3; |
||||
|
public T V4; |
||||
|
public T V5; |
||||
|
public T V6; |
||||
|
public T V7; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public override readonly string ToString() |
||||
|
{ |
||||
|
return $"Octet<{typeof(T)}>({this.V0},{this.V1},{this.V2},{this.V3},{this.V4},{this.V5},{this.V6},{this.V7})"; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Extension methods for the <see cref="Octet{T}"/> type.
|
||||
|
/// </summary>
|
||||
|
internal static class OctetExtensions |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Loads the fields in a target <see cref="Octet{T}"/> of <see cref="uint"/> from one of <see cref="byte"/> type.
|
||||
|
/// </summary>
|
||||
|
/// <param name="destination">The target <see cref="Octet{T}"/> of <see cref="uint"/> instance.</param>
|
||||
|
/// <param name="source">The source <see cref="Octet{T}"/> of <see cref="byte"/> instance.</param>
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public static void LoadFrom(ref this Octet<uint> destination, ref Octet<byte> source) |
||||
|
{ |
||||
|
destination.V0 = source.V0; |
||||
|
destination.V1 = source.V1; |
||||
|
destination.V2 = source.V2; |
||||
|
destination.V3 = source.V3; |
||||
|
destination.V4 = source.V4; |
||||
|
destination.V5 = source.V5; |
||||
|
destination.V6 = source.V6; |
||||
|
destination.V7 = source.V7; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Loads the fields in a target <see cref="Octet{T}"/> of <see cref="byte"/> from one of <see cref="uint"/> type.
|
||||
|
/// </summary>
|
||||
|
/// <param name="destination">The target <see cref="Octet{T}"/> of <see cref="byte"/> instance.</param>
|
||||
|
/// <param name="source">The source <see cref="Octet{T}"/> of <see cref="uint"/> instance.</param>
|
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
public static void LoadFrom(ref this Octet<byte> destination, ref Octet<uint> source) |
||||
|
{ |
||||
|
destination.V0 = (byte)source.V0; |
||||
|
destination.V1 = (byte)source.V1; |
||||
|
destination.V2 = (byte)source.V2; |
||||
|
destination.V3 = (byte)source.V3; |
||||
|
destination.V4 = (byte)source.V4; |
||||
|
destination.V5 = (byte)source.V5; |
||||
|
destination.V6 = (byte)source.V6; |
||||
|
destination.V7 = (byte)source.V7; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,68 @@ |
|||||
|
// 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.ImageSharp.Memory; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Jpeg.Components |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Cache 8 pixel rows on the stack, which may originate from different buffers of a <see cref="MemoryGroup{T}"/>.
|
||||
|
/// </summary>
|
||||
|
[StructLayout(LayoutKind.Sequential)] |
||||
|
internal readonly ref struct RowOctet<T> |
||||
|
where T : struct |
||||
|
{ |
||||
|
private readonly Span<T> row0; |
||||
|
private readonly Span<T> row1; |
||||
|
private readonly Span<T> row2; |
||||
|
private readonly Span<T> row3; |
||||
|
private readonly Span<T> row4; |
||||
|
private readonly Span<T> row5; |
||||
|
private readonly Span<T> row6; |
||||
|
private readonly Span<T> row7; |
||||
|
|
||||
|
public RowOctet(Buffer2D<T> buffer, int startY) |
||||
|
{ |
||||
|
int y = startY; |
||||
|
int height = buffer.Height; |
||||
|
this.row0 = y < height ? buffer.GetRowSpan(y++) : default; |
||||
|
this.row1 = y < height ? buffer.GetRowSpan(y++) : default; |
||||
|
this.row2 = y < height ? buffer.GetRowSpan(y++) : default; |
||||
|
this.row3 = y < height ? buffer.GetRowSpan(y++) : default; |
||||
|
this.row4 = y < height ? buffer.GetRowSpan(y++) : default; |
||||
|
this.row5 = y < height ? buffer.GetRowSpan(y++) : default; |
||||
|
this.row6 = y < height ? buffer.GetRowSpan(y++) : default; |
||||
|
this.row7 = y < height ? buffer.GetRowSpan(y) : default; |
||||
|
} |
||||
|
|
||||
|
public Span<T> this[int y] |
||||
|
{ |
||||
|
[MethodImpl(InliningOptions.ShortMethod)] |
||||
|
get |
||||
|
{ |
||||
|
// No unsafe tricks, since Span<T> can't be used as a generic argument
|
||||
|
return y switch |
||||
|
{ |
||||
|
0 => this.row0, |
||||
|
1 => this.row1, |
||||
|
2 => this.row2, |
||||
|
3 => this.row3, |
||||
|
4 => this.row4, |
||||
|
5 => this.row5, |
||||
|
6 => this.row6, |
||||
|
7 => this.row7, |
||||
|
_ => ThrowIndexOutOfRangeException() |
||||
|
}; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
[MethodImpl(InliningOptions.ColdPath)] |
||||
|
private static Span<T> ThrowIndexOutOfRangeException() |
||||
|
{ |
||||
|
throw new IndexOutOfRangeException(); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue