Add Bgra5551 pixeloperations plus tests.

src/ImageSharp/ImageSharp.csproj

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
@@ -76,6 +76,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>Bgra32.PixelOperations.Generated.tt</DependentUpon>
     </Compile>
+    <Compile Update="PixelFormats\PixelImplementations\Generated\Bgra5551.PixelOperations.Generated.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Bgra5551.PixelOperations.Generated.tt</DependentUpon>
+    </Compile>
     <Compile Update="PixelFormats\PixelImplementations\Generated\L8.PixelOperations.Generated.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -151,6 +156,10 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Bgra32.PixelOperations.Generated.cs</LastGenOutput>
     </None>
+    <None Update="PixelFormats\PixelImplementations\Generated\Bgra5551.PixelOperations.Generated.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Bgra5551.PixelOperations.Generated.cs</LastGenOutput>
+    </None>
     <None Update="PixelFormats\PixelImplementations\Generated\L8.PixelOperations.Generated.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>L8.PixelOperations.Generated.cs</LastGenOutput>

src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -14,7 +14,7 @@ namespace SixLabors.ImageSharp.PixelFormats
     /// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form.
     /// </para>
     /// </summary>
-    public struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
+    public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="Bgra5551"/> struct.
@@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp.PixelFormats
         public static bool operator !=(Bgra5551 left, Bgra5551 right) => !left.Equals(right);
 
         /// <inheritdoc />
-        public PixelOperations<Bgra5551> CreatePixelOperations() => new PixelOperations<Bgra5551>();
+        public PixelOperations<Bgra5551> CreatePixelOperations() => new PixelOperations();
 
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
@@ -163,4 +163,4 @@ namespace SixLabors.ImageSharp.PixelFormats
                    | (((int)Math.Round(vector.W) & 0x1) << 15));
         }
     }
-}
+}

src/ImageSharp/PixelFormats/PixelImplementations/Generated/Argb32.PixelOperations.Generated.cs

@@ -222,6 +222,24 @@ namespace SixLabors.ImageSharp.PixelFormats
                     dp.FromArgb32(sp);
                 }
             }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<Argb32> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Argb32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Argb32 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromArgb32(sp);
+                }
+            }
             /// <inheritdoc />
             internal override void From<TSourcePixel>(
                 Configuration configuration,

src/ImageSharp/PixelFormats/PixelImplementations/Generated/Bgr24.PixelOperations.Generated.cs

@@ -197,6 +197,24 @@ namespace SixLabors.ImageSharp.PixelFormats
                     dp.FromBgr24(sp);
                 }
             }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<Bgr24> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgr24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgr24 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgr24(sp);
+                }
+            }
             /// <inheritdoc />
             internal override void From<TSourcePixel>(
                 Configuration configuration,

src/ImageSharp/PixelFormats/PixelImplementations/Generated/Bgra32.PixelOperations.Generated.cs

@@ -222,6 +222,24 @@ namespace SixLabors.ImageSharp.PixelFormats
                     dp.FromBgra32(sp);
                 }
             }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<Bgra32> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra32 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra32(sp);
+                }
+            }
             /// <inheritdoc />
             internal override void From<TSourcePixel>(
                 Configuration configuration,

src/ImageSharp/PixelFormats/PixelImplementations/Generated/Bgra5551.PixelOperations.Generated.cs

@@ -0,0 +1,218 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+// <auto-generated />
+
+using SixLabors.ImageSharp.PixelFormats.Utils;
+using System;
+using System.Buffers;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+
+
+namespace SixLabors.ImageSharp.PixelFormats
+{
+    /// <content>
+    /// Provides optimized overrides for bulk operations.
+    /// </content>
+    public partial struct Bgra5551
+    {
+        /// <summary>
+        /// Provides optimized overrides for bulk operations.
+        /// </summary>
+        internal class PixelOperations : PixelOperations<Bgra5551>
+        {
+            /// <inheritdoc />
+            internal override void FromBgra5551(Configuration configuration, ReadOnlySpan<Bgra5551> source, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(source, destPixels, nameof(destPixels));
+
+                source.CopyTo(destPixels);
+            }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                sourcePixels.CopyTo(destPixels);
+            }
+
+
+            /// <inheritdoc />
+            internal override void ToArgb32(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<Argb32> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Argb32 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Argb32 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra5551(sp);
+                }
+            }
+
+            /// <inheritdoc />
+            internal override void ToBgr24(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<Bgr24> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgr24 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgr24 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra5551(sp);
+                }
+            }
+
+            /// <inheritdoc />
+            internal override void ToBgra32(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<Bgra32> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra32 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra32 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra5551(sp);
+                }
+            }
+
+            /// <inheritdoc />
+            internal override void ToL8(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<L8> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref L8 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref L8 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra5551(sp);
+                }
+            }
+
+            /// <inheritdoc />
+            internal override void ToL16(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<L16> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref L16 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref L16 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra5551(sp);
+                }
+            }
+
+            /// <inheritdoc />
+            internal override void ToRgb24(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<Rgb24> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Rgb24 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Rgb24 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra5551(sp);
+                }
+            }
+
+            /// <inheritdoc />
+            internal override void ToRgba32(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<Rgba32> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Rgba32 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Rgba32 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra5551(sp);
+                }
+            }
+
+            /// <inheritdoc />
+            internal override void ToRgb48(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<Rgb48> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Rgb48 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra5551(sp);
+                }
+            }
+
+            /// <inheritdoc />
+            internal override void ToRgba64(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<Rgba64> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Rgba64 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromBgra5551(sp);
+                }
+            }
+            /// <inheritdoc />
+            internal override void From<TSourcePixel>(
+                Configuration configuration,
+                ReadOnlySpan<TSourcePixel> sourcePixels,
+                Span<Bgra5551> destinationPixels)
+            {
+                PixelOperations<TSourcePixel>.Instance.ToBgra5551(configuration, sourcePixels, destinationPixels);
+            }
+
+        }
+    }
+}

src/ImageSharp/PixelFormats/PixelImplementations/Generated/Bgra5551.PixelOperations.Generated.tt

@@ -0,0 +1,19 @@
+<#@include file="_Common.ttinclude" #>
+<#@ output extension=".cs" #>
+
+namespace SixLabors.ImageSharp.PixelFormats
+{
+    /// <content>
+    /// Provides optimized overrides for bulk operations.
+    /// </content>
+    public partial struct Bgra5551
+    {
+        /// <summary>
+        /// Provides optimized overrides for bulk operations.
+        /// </summary>
+        internal class PixelOperations : PixelOperations<Bgra5551>
+        {
+            <# GenerateAllDefaultConversionMethods("Bgra5551"); #>
+        }
+    }
+}

src/ImageSharp/PixelFormats/PixelImplementations/Generated/L16.PixelOperations.Generated.cs

@@ -185,6 +185,24 @@ namespace SixLabors.ImageSharp.PixelFormats
                     dp.FromL16(sp);
                 }
             }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<L16> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromL16(sp);
+                }
+            }
             /// <inheritdoc />
             internal override void From<TSourcePixel>(
                 Configuration configuration,

src/ImageSharp/PixelFormats/PixelImplementations/Generated/L8.PixelOperations.Generated.cs

@@ -185,6 +185,24 @@ namespace SixLabors.ImageSharp.PixelFormats
                     dp.FromL8(sp);
                 }
             }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<L8> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromL8(sp);
+                }
+            }
             /// <inheritdoc />
             internal override void From<TSourcePixel>(
                 Configuration configuration,

src/ImageSharp/PixelFormats/PixelImplementations/Generated/Rgb24.PixelOperations.Generated.cs

@@ -196,6 +196,24 @@ namespace SixLabors.ImageSharp.PixelFormats
                     dp.FromRgb24(sp);
                 }
             }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<Rgb24> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Rgb24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Rgb24 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromRgb24(sp);
+                }
+            }
             /// <inheritdoc />
             internal override void From<TSourcePixel>(
                 Configuration configuration,

src/ImageSharp/PixelFormats/PixelImplementations/Generated/Rgb48.PixelOperations.Generated.cs

@@ -185,6 +185,24 @@ namespace SixLabors.ImageSharp.PixelFormats
                     dp.FromRgb48(sp);
                 }
             }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<Rgb48> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromRgb48(sp);
+                }
+            }
             /// <inheritdoc />
             internal override void From<TSourcePixel>(
                 Configuration configuration,

src/ImageSharp/PixelFormats/PixelImplementations/Generated/Rgba32.PixelOperations.Generated.cs

@@ -211,6 +211,24 @@ namespace SixLabors.ImageSharp.PixelFormats
                     dp.FromRgba32(sp);
                 }
             }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<Rgba32> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Rgba32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Rgba32 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromRgba32(sp);
+                }
+            }
             /// <inheritdoc />
             internal override void From<TSourcePixel>(
                 Configuration configuration,

src/ImageSharp/PixelFormats/PixelImplementations/Generated/Rgba64.PixelOperations.Generated.cs

@@ -185,6 +185,24 @@ namespace SixLabors.ImageSharp.PixelFormats
                     dp.FromRgba64(sp);
                 }
             }
+
+            /// <inheritdoc />
+            internal override void ToBgra5551(Configuration configuration, ReadOnlySpan<Rgba64> sourcePixels, Span<Bgra5551> destPixels)
+            {
+                Guard.NotNull(configuration, nameof(configuration));
+                Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+                ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
+                ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destPixels);
+
+                for (int i = 0; i < sourcePixels.Length; i++)
+                {
+                    ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
+                    ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
+
+                    dp.FromRgba64(sp);
+                }
+            }
             /// <inheritdoc />
             internal override void From<TSourcePixel>(
                 Configuration configuration,

src/ImageSharp/PixelFormats/PixelImplementations/Generated/_Common.ttinclude

@@ -1,4 +1,4 @@
-<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ template debug="false" hostspecific="false" language="C#" #>
 <#@ assembly name="System.Core" #>
 <#@ import namespace="System.Linq" #>
 <#@ import namespace="System.Text" #>
@@ -15,7 +15,7 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 <#+
-    static readonly string[] CommonPixelTypes = { "Argb32", "Bgr24", "Bgra32", "L8", "L16", "Rgb24", "Rgba32", "Rgb48", "Rgba64" };
+    static readonly string[] CommonPixelTypes = { "Argb32", "Bgr24", "Bgra32", "L8", "L16", "Rgb24", "Rgba32", "Rgb48", "Rgba64", "Bgra5551" };
 
     static readonly string[] Optimized32BitTypes = { "Rgba32", "Argb32", "Bgra32" };
 

tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs

@@ -280,15 +280,15 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelOperations
 
 
         public static readonly TheoryData<IPixel> Generic_To_Data = new TheoryData<IPixel>
-                                                    {
+        {
-                                                        default(Rgba32),
+            default(Rgba32),
-                                                        default(Bgra32),
+            default(Bgra32),
-                                                        default(Rgb24),
+            default(Rgb24),
-                                                        default(L8),
+            default(L8),
-                                                        default(L16),
+            default(L16),
-                                                        default(Rgb48),
+            default(Rgb48),
-                                                        default(Rgba64)
+            default(Rgba64)
-                                                    };
+        };
 
         [Theory]
         [MemberData(nameof(Generic_To_Data))]
@@ -569,6 +569,54 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelOperations
             );
         }
 
+        [Theory]
+        [MemberData(nameof(ArraySizesData))]
+        public void FromBgra5551Bytes(int count)
+        {
+            int size = Unsafe.SizeOf<Bgra5551>();
+            byte[] source = CreateByteTestData(count * size);
+            var expected = new TPixel[count];
+
+            for (int i = 0; i < count; i++)
+            {
+                int offset = i * size;
+
+                Bgra5551 bgra = MemoryMarshal.Cast<byte, Bgra5551>(source.AsSpan().Slice(offset, size))[0];
+                expected[i].FromBgra5551(bgra);
+            }
+
+            TestOperation(
+                source,
+                expected,
+                (s, d) => Operations.FromBgra5551Bytes(this.Configuration, s, d.GetSpan(), count)
+            );
+        }
+
+        [Theory]
+        [MemberData(nameof(ArraySizesData))]
+        public void ToBgra5551Bytes(int count)
+        {
+            int size = Unsafe.SizeOf<Bgra5551>();
+            TPixel[] source = CreatePixelTestData(count);
+            var expected = new byte[count * size];
+            Bgra5551 bgra = default;
+
+            for (int i = 0; i < count; i++)
+            {
+                int offset = i * size;
+                bgra.FromScaledVector4(source[i].ToScaledVector4());
+                OctetBytes bytes = Unsafe.As<Bgra5551, OctetBytes>(ref bgra);
+                expected[offset] = bytes[0];
+                expected[offset + 1] = bytes[1];
+            }
+
+            TestOperation(
+                source,
+                expected,
+                (s, d) => Operations.ToBgra5551Bytes(this.Configuration, s, d.GetSpan(), count)
+            );
+        }
+
         [Theory]
         [MemberData(nameof(ArraySizesData))]
         public void FromRgb24Bytes(int count)
@@ -761,90 +809,90 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelOperations
         }
 
 
-            [Theory]
+        [Theory]
-            [MemberData(nameof(ArraySizesData))]
+        [MemberData(nameof(ArraySizesData))]
-            public void FromL8(int count)
+        public void FromL8(int count)
-            {
+        {
-                byte[] sourceBytes = CreateByteTestData(count);
+            byte[] sourceBytes = CreateByteTestData(count);
-                L8[] source = sourceBytes.Select(b => new L8(b)).ToArray();
+            L8[] source = sourceBytes.Select(b => new L8(b)).ToArray();
-                var expected = new TPixel[count];
+            var expected = new TPixel[count];
-
 
-                for (int i = 0; i < count; i++)
-                {
-                    expected[i].FromL8(source[i]);
-                }
 
-                TestOperation(
+            for (int i = 0; i < count; i++)
-                    source,
+            {
-                    expected,
+                expected[i].FromL8(source[i]);
-                    (s, d) => Operations.FromL8(this.Configuration, s, d.GetSpan())
-                );
             }
 
-            [Theory]
+            TestOperation(
-            [MemberData(nameof(ArraySizesData))]
+                source,
-            public void ToL8(int count)
+                expected,
-            {
+                (s, d) => Operations.FromL8(this.Configuration, s, d.GetSpan())
-                TPixel[] source = CreatePixelTestData(count);
+            );
-                var expected = new L8[count];
+        }
 
-                for (int i = 0; i < count; i++)
+        [Theory]
-                {
+        [MemberData(nameof(ArraySizesData))]
-                    expected[i].FromScaledVector4(source[i].ToScaledVector4());
+        public void ToL8(int count)
-                }
+        {
+            TPixel[] source = CreatePixelTestData(count);
+            var expected = new L8[count];
 
-                TestOperation(
+            for (int i = 0; i < count; i++)
-                    source,
+            {
-                    expected,
+                expected[i].FromScaledVector4(source[i].ToScaledVector4());
-                    (s, d) => Operations.ToL8(this.Configuration, s, d.GetSpan())
-                );
             }
 
-            [Theory]
+            TestOperation(
-            [MemberData(nameof(ArraySizesData))]
+                source,
-            public void FromL16(int count)
+                expected,
-            {
+                (s, d) => Operations.ToL8(this.Configuration, s, d.GetSpan())
-                L16[] source = CreateVector4TestData(count).Select(v =>
+            );
-                {
+        }
-                    L16 g = default;
-                    g.FromVector4(v);
-                    return g;
-                }).ToArray();
 
-                var expected = new TPixel[count];
+        [Theory]
+        [MemberData(nameof(ArraySizesData))]
+        public void FromL16(int count)
+        {
+            L16[] source = CreateVector4TestData(count).Select(v =>
+            {
+                L16 g = default;
+                g.FromVector4(v);
+                return g;
+            }).ToArray();
 
-                for (int i = 0; i < count; i++)
+            var expected = new TPixel[count];
-                {
-                    expected[i].FromL16(source[i]);
-                }
 
-                TestOperation(
+            for (int i = 0; i < count; i++)
-                    source,
+            {
-                    expected,
+                expected[i].FromL16(source[i]);
-                    (s, d) => Operations.FromL16(this.Configuration, s, d.GetSpan())
-                );
             }
 
-            [Theory]
+            TestOperation(
-            [MemberData(nameof(ArraySizesData))]
+                source,
-            public void ToL16(int count)
+                expected,
-            {
+                (s, d) => Operations.FromL16(this.Configuration, s, d.GetSpan())
-                TPixel[] source = CreatePixelTestData(count);
+            );
-                var expected = new L16[count];
+        }
 
-                for (int i = 0; i < count; i++)
+        [Theory]
-                {
+        [MemberData(nameof(ArraySizesData))]
-                    expected[i].FromScaledVector4(source[i].ToScaledVector4());
+        public void ToL16(int count)
-                }
+        {
+            TPixel[] source = CreatePixelTestData(count);
+            var expected = new L16[count];
 
-                TestOperation(
+            for (int i = 0; i < count; i++)
-                    source,
+            {
-                    expected,
+                expected[i].FromScaledVector4(source[i].ToScaledVector4());
-                    (s, d) => Operations.ToL16(this.Configuration, s, d.GetSpan())
-                );
             }
 
+            TestOperation(
+                source,
+                expected,
+                (s, d) => Operations.ToL16(this.Configuration, s, d.GetSpan())
+            );
+        }
+
         public delegate void RefAction<T1>(ref T1 arg1);
 
         internal static Vector4[] CreateExpectedVector4Data(TPixel[] source, RefAction<Vector4> vectorModifier = null)