Add support for encoding 16 bit per pixel bitmaps (#899)

* Implemented encoding of 16 bits per pixel bitmaps

* Add unit tests for 16 bit encoding and Bgra5551 conversion

* Add additional Bgra5551 pixel conversion tests

* Add Bgra5551 tests for Short2/4 and HalfVector2/4

* Use scaled vector conversion

src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs

@@ -8,6 +8,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     /// </summary>
     public enum BmpBitsPerPixel : short
     {
+        /// <summary>
+        /// 16 bits per pixel. Each pixel consists of 2 bytes.
+        /// </summary>
+        Pixel16 = 16,
+
         /// <summary>
         /// 24 bits per pixel. Each pixel consists of 3 bytes.
         /// </summary>

src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs

@@ -1022,7 +1022,8 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             this.bmpMetadata.InfoHeaderType = infoHeaderType;
 
             // We can only encode at these bit rates so far.
-            if (bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel24)
+            if (bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel16)
+                || bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel24)
                 || bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel32))
             {
                 this.bmpMetadata.BitsPerPixel = (BmpBitsPerPixel)bitsPerPixel;

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -194,6 +194,10 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                 case BmpBitsPerPixel.Pixel24:
                     this.Write24Bit(stream, pixels);
                     break;
+
+                case BmpBitsPerPixel.Pixel16:
+                    this.Write16Bit(stream, pixels);
+                    break;
             }
         }
 
@@ -246,5 +250,31 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                 }
             }
         }
+
+        /// <summary>
+        /// Writes the 16bit color palette to the stream.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+        /// <param name="stream">The <see cref="Stream"/> to write to.</param>
+        /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
+        private void Write16Bit<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (IManagedByteBuffer row = this.AllocateRow(pixels.Width, 2))
+            {
+                for (int y = pixels.Height - 1; y >= 0; y--)
+                {
+                    Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+
+                    PixelOperations<TPixel>.Instance.ToBgra5551Bytes(
+                        this.configuration,
+                        pixelSpan,
+                        row.GetSpan(),
+                        pixelSpan.Length);
+
+                    stream.Write(row.Array, 0, row.Length());
+                }
+            }
+        }
     }
 }

src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs

@@ -6,7 +6,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     /// <summary>
     /// Configuration options for use during bmp encoding
     /// </summary>
-    /// <remarks>The encoder can currently only write 24-bit and 32-bit rgb images to streams.</remarks>
+    /// <remarks>The encoder can currently only write 16-bit, 24-bit and 32-bit rgb images to streams.</remarks>
     internal interface IBmpEncoderOptions
     {
         /// <summary>

src/ImageSharp/PixelFormats/IPixel.cs

@@ -61,6 +61,12 @@ namespace SixLabors.ImageSharp.PixelFormats
         /// <param name="source">The <see cref="Argb32"/> value.</param>
         void FromArgb32(Argb32 source);
 
+        /// <summary>
+        /// Initializes the pixel instance from an <see cref="Bgra5551"/> value.
+        /// </summary>
+        /// <param name="source">The <see cref="Bgra5551"/> value.</param>
+        void FromBgra5551(Bgra5551 source);
+
         /// <summary>
         /// Initializes the pixel instance from an <see cref="Bgr24"/> value.
         /// </summary>

src/ImageSharp/PixelFormats/PixelImplementations/Alpha8.cs

@@ -87,6 +87,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.PackedValue = source.A;
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.PackedValue = byte.MaxValue;

src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs

@@ -187,6 +187,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromArgb32(Argb32 source) => this.PackedValue = source.PackedValue;
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgr24(Bgr24 source)

src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs

@@ -109,6 +109,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgr24(Bgr24 source) => this = source;
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source)

src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs

@@ -87,6 +87,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromArgb32(Argb32 source) => this.FromVector4(source.ToVector4());
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromVector4(source.ToVector4());
+
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs

@@ -159,6 +159,10 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.A = byte.MaxValue;
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this = source;

src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs

@@ -90,6 +90,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs

@@ -87,6 +87,10 @@ namespace SixLabors.ImageSharp.PixelFormats
                         (this.PackedValue >> 15) & 0x01);
         }
 
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this = source;
+
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs

@@ -111,6 +111,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/Gray16.cs

@@ -106,6 +106,10 @@ namespace SixLabors.ImageSharp.PixelFormats
                 ImageMaths.UpscaleFrom8BitTo16Bit(source.B));
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.PackedValue = ImageMaths.UpscaleFrom8BitTo16Bit(source.PackedValue);

src/ImageSharp/PixelFormats/PixelImplementations/Gray8.cs

@@ -97,6 +97,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.PackedValue = ImageMaths.Get8BitBT709Luminance(source.R, source.G, source.B);
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.PackedValue = source.PackedValue;

src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs

@@ -88,6 +88,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs

@@ -99,6 +99,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs

@@ -107,6 +107,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs

@@ -8,7 +8,7 @@ using System.Runtime.CompilerServices;
 namespace SixLabors.ImageSharp.PixelFormats
 {
     /// <summary>
-    /// Packed packed pixel type containing two 8-bit signed normalized values, ranging from −1 to 1.
+    /// Packed pixel type containing two 8-bit signed normalized values, ranging from −1 to 1.
     /// <para>
     /// Ranges from [-1, -1, 0, 1] to [1, 1, 0, 1] in vector form.
     /// </para>
@@ -107,10 +107,11 @@ namespace SixLabors.ImageSharp.PixelFormats
 
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void ToRgba32(ref Rgba32 dest)
-        {
-            dest.FromScaledVector4(this.ToScaledVector4());
-        }
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
 
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]

src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs

@@ -110,6 +110,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs

@@ -105,6 +105,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs

@@ -112,6 +112,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs

@@ -93,6 +93,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs

@@ -156,6 +156,10 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.B = rgb;
         }
 
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromRgb24(Rgb24 source) => this = source;

src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs

@@ -126,6 +126,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromRgba64(Rgba64 source) => this = source.Rgb;
 
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source)

src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs

@@ -99,6 +99,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs

@@ -266,6 +266,10 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.A = source.A;
         }
 
+        /// <inheritdoc />
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source)

src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs

@@ -9,7 +9,7 @@ using System.Runtime.InteropServices;
 namespace SixLabors.ImageSharp.PixelFormats
 {
     /// <summary>
-    /// Packed pixel type containing four 16-bit unsigned normalized values ranging from 0 to 635535.
+    /// Packed pixel type containing four 16-bit unsigned normalized values ranging from 0 to 65535.
     /// <para>
     /// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form.
     /// </para>
@@ -154,6 +154,10 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.A = ImageMaths.UpscaleFrom8BitTo16Bit(source.A);
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source)

src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs

@@ -134,6 +134,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());
@@ -152,10 +156,7 @@ namespace SixLabors.ImageSharp.PixelFormats
 
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void ToRgba32(ref Rgba32 dest)
-        {
-            dest.FromScaledVector4(this.ToScaledVector4());
-        }
+        public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
 
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]

src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs

@@ -111,6 +111,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());
@@ -129,10 +133,7 @@ namespace SixLabors.ImageSharp.PixelFormats
 
         /// <inheritdoc />
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void ToRgba32(ref Rgba32 dest)
-        {
-            dest.FromScaledVector4(this.ToScaledVector4());
-        }
+        public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
 
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]

src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs

@@ -116,6 +116,10 @@ namespace SixLabors.ImageSharp.PixelFormats
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
 
+        /// <inheritdoc/>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
         public void FromGray8(Gray8 source) => this.FromScaledVector4(source.ToScaledVector4());

src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.cs

@@ -657,5 +657,77 @@ namespace SixLabors.ImageSharp.PixelFormats
         {
             this.ToRgba64(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Rgba64>(destBytes));
         }
+
+        /// <summary>
+        /// Converts all pixels in 'source` span of <see cref="Bgra5551"/> into a span of <typeparamref name="TPixel"/>-s.
+        /// </summary>
+        /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
+        /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Bgra5551"/> data.</param>
+        /// <param name="destPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+        internal virtual void FromBgra5551(Configuration configuration, ReadOnlySpan<Bgra5551> source, Span<TPixel> destPixels)
+        {
+            Guard.DestinationShouldNotBeTooShort(source, destPixels, nameof(destPixels));
+            
+            ref Bgra5551 sourceBaseRef = ref MemoryMarshal.GetReference(source);
+            ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destPixels);
+
+            for (int i = 0; i < source.Length; i++)
+            {
+                ref Bgra5551 sp = ref Unsafe.Add(ref sourceBaseRef, i);
+                ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
+
+                dp.FromBgra5551(sp);
+            }
+        }
+
+        /// <summary>
+        /// A helper for <see cref="FromBgra5551(Configuration, ReadOnlySpan{Bgra5551}, Span{TPixel})"/> that expects a byte span.
+        /// The layout of the data in 'sourceBytes' must be compatible with <see cref="Bgra5551"/> layout.
+        /// </summary>
+        /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
+        /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
+        /// <param name="destPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+        /// <param name="count">The number of pixels to convert.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void FromBgra5551Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destPixels, int count)
+        {
+            this.FromBgra5551(configuration, MemoryMarshal.Cast<byte, Bgra5551>(sourceBytes).Slice(0, count), destPixels);
+        }
+
+        /// <summary>
+        /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Bgra5551"/>-s.
+        /// </summary>
+        /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
+        /// <param name="sourcePixels">The span of source pixels</param>
+        /// <param name="destPixels">The destination span of <see cref="Bgra5551"/> data.</param>
+        internal virtual void ToBgra5551(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Bgra5551> destPixels)
+        {
+            Guard.DestinationShouldNotBeTooShort(sourcePixels, destPixels, nameof(destPixels));
+
+            ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
+            ref Bgra5551 destBaseRef = ref MemoryMarshal.GetReference(destPixels);
+
+            for (int i = 0; i < sourcePixels.Length; i++)
+            {
+                ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
+                ref Bgra5551 dp = ref Unsafe.Add(ref destBaseRef, i);
+
+                dp.FromScaledVector4(sp.ToScaledVector4());
+            }
+        }
+
+        /// <summary>
+        /// A helper for <see cref="ToBgra5551(Configuration, ReadOnlySpan{TPixel}, Span{Bgra5551})"/> that expects a byte span as destination.
+        /// The layout of the data in 'destBytes' must be compatible with <see cref="Bgra5551"/> layout.
+        /// </summary>
+        /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
+        /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
+        /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+        /// <param name="count">The number of pixels to convert.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void ToBgra5551Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+        {
+            this.ToBgra5551(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Bgra5551>(destBytes));
+        }
     }
 }

src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.tt

@@ -136,5 +136,8 @@ namespace SixLabors.ImageSharp.PixelFormats
     GenerateFromMethods("Rgba64");
     GenerateToDestFormatMethods("Rgba64");
 
+    GenerateFromMethods("Bgra5551");
+    GenerateToDestFormatMethods("Bgra5551");
+
 #>    }
 }

tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs

@@ -11,7 +11,7 @@ using Xunit;
 
 // ReSharper disable InconsistentNaming
 
-namespace SixLabors.ImageSharp.Tests
+namespace SixLabors.ImageSharp.Tests.Formats.Bmp
 {
     using SixLabors.ImageSharp.Metadata;
     using static TestImages.Bmp;

tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs

@@ -6,10 +6,11 @@ using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
+
 using Xunit;
 using Xunit.Abstractions;
 
-namespace SixLabors.ImageSharp.Tests
+namespace SixLabors.ImageSharp.Tests.Formats.Bmp
 {
     using static TestImages.Bmp;
 
@@ -25,16 +26,16 @@ namespace SixLabors.ImageSharp.Tests
         public static readonly TheoryData<string, int, int, PixelResolutionUnit> RatioFiles =
         new TheoryData<string, int, int, PixelResolutionUnit>
         {
-            { TestImages.Bmp.Car, 3780, 3780 , PixelResolutionUnit.PixelsPerMeter },
-            { TestImages.Bmp.V5Header, 3780, 3780 , PixelResolutionUnit.PixelsPerMeter },
-            { TestImages.Bmp.RLE8, 2835, 2835, PixelResolutionUnit.PixelsPerMeter }
+            { Car, 3780, 3780 , PixelResolutionUnit.PixelsPerMeter },
+            { V5Header, 3780, 3780 , PixelResolutionUnit.PixelsPerMeter },
+            { RLE8, 2835, 2835, PixelResolutionUnit.PixelsPerMeter }
         };
 
         public static readonly TheoryData<string, BmpBitsPerPixel> BmpBitsPerPixelFiles =
         new TheoryData<string, BmpBitsPerPixel>
         {
-            { TestImages.Bmp.Car, BmpBitsPerPixel.Pixel24 },
-            { TestImages.Bmp.Bit32Rgb, BmpBitsPerPixel.Pixel32 }
+            { Car, BmpBitsPerPixel.Pixel24 },
+            { Bit32Rgb, BmpBitsPerPixel.Pixel32 }
         };
 
         public BmpEncoderTests(ITestOutputHelper output) => this.Output = output;
@@ -111,6 +112,8 @@ namespace SixLabors.ImageSharp.Tests
         [WithFile(WinBmpv5, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
         // WinBmpv3 is a 24 bits per pixel image
         [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
+        [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
+        [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
         public void Encode_WithV3Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             // if supportTransparency is false, a v3 bitmap header will be written
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
@@ -121,6 +124,8 @@ namespace SixLabors.ImageSharp.Tests
         [WithFile(WinBmpv4, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
         [WithFile(WinBmpv5, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
         [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
+        [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
+        [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
         public void Encode_WithV4Header_Works<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
 

tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs

@@ -94,5 +94,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             input.ToRgba32(ref actual);
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void Alpha8_FromBgra5551()
+        {
+            // arrange
+            var alpha = default(Alpha8);
+            byte expected = byte.MaxValue;
+
+            // act
+            alpha.FromBgra5551(new Bgra5551(0.0f, 0.0f, 0.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, alpha.PackedValue);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs

@@ -60,6 +60,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Argb32_FromBgra5551()
+        {
+            // arrange
+            var argb = default(Argb32);
+            uint expected = uint.MaxValue;
+
+            // act
+            argb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, argb.PackedValue);
+        }
+
         [Fact]
         public void Argb32_Clamping()
         {

tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs

@@ -95,5 +95,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 
             Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
         }
+
+        [Fact]
+        public void Bgr24_FromBgra5551()
+        {
+            // arrange
+            var bgr = default(Bgr24);
+
+            // act
+            bgr.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(255, bgr.R);
+            Assert.Equal(255, bgr.G);
+            Assert.Equal(255, bgr.B);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs

@@ -63,6 +63,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Bgr565_FromBgra5551()
+        {
+            // arrange
+            var bgr = default(Bgr565);
+            ushort expected = ushort.MaxValue;
+
+            // act
+            bgr.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, bgr.PackedValue);
+        }
+
         [Fact]
         public void Bgr565_Clamping()
         {

tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs

@@ -102,5 +102,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 
             Assert.Equal(Vec(1, 2, 3, 4), rgb.ToVector4());
         }
+
+        [Fact]
+        public void Bgra32_FromBgra5551()
+        {
+            // arrange
+            var bgra = default(Bgra32);
+            uint expected = uint.MaxValue;
+
+            // act
+            bgra.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, bgra.PackedValue);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs

@@ -64,6 +64,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Bgra4444_FromBgra5551()
+        {
+            // arrange
+            var bgra = default(Bgra4444);
+            ushort expected = ushort.MaxValue;
+
+            // act
+            bgra.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, bgra.PackedValue);
+        }
+
         [Fact]
         public void Bgra4444_Clamping()
         {

tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
@@ -18,6 +19,13 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             float w = 0x1;
             Assert.Equal(0xeacd, new Bgra5551(x / 0x1f, y / 0x1f, z / 0x1f, w).PackedValue);
             Assert.Equal(3088, new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f).PackedValue);
+
+            Assert.Equal(0xFFFF, new Bgra5551(Vector4.One).PackedValue);
+            Assert.Equal(0x7C00, new Bgra5551(Vector4.UnitX).PackedValue);
+            Assert.Equal(0x03E0, new Bgra5551(Vector4.UnitY).PackedValue);
+            Assert.Equal(0x001F, new Bgra5551(Vector4.UnitZ).PackedValue);
+            Assert.Equal(0x8000, new Bgra5551(Vector4.UnitW).PackedValue);
+
             // Test the limits.
             Assert.Equal(0x0, new Bgra5551(Vector4.Zero).PackedValue);
             Assert.Equal(0xFFFF, new Bgra5551(Vector4.One).PackedValue);
@@ -53,7 +61,6 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Vector4 scaled = new Bgra5551(Vector4.One).ToScaledVector4();
             int expected = 0xFFFF;
             var pixel = default(Bgra5551);
-            pixel.FromScaledVector4(scaled);
 
             // act
             pixel.FromScaledVector4(scaled);
@@ -63,6 +70,126 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Bgra5551_FromRgba32()
+        {
+            // arrange
+            var bgra1 = default(Bgra5551);
+            var bgra2 = default(Bgra5551);
+            ushort expectedPackedValue1 = ushort.MaxValue;
+            ushort expectedPackedValue2 = 0xFC1F;
+
+            // act
+            bgra1.FromRgba32(new Rgba32(255, 255, 255, 255));
+            bgra2.FromRgba32(new Rgba32(255, 0, 255, 255));
+
+            // assert
+            Assert.Equal(expectedPackedValue1, bgra1.PackedValue);
+            Assert.Equal(expectedPackedValue2, bgra2.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra5551_FromBgra32()
+        {
+            // arrange
+            var bgra1 = default(Bgra5551);
+            var bgra2 = default(Bgra5551);
+            ushort expectedPackedValue1 = ushort.MaxValue;
+            ushort expectedPackedValue2 = 0xFC1F;
+
+            // act
+            bgra1.FromBgra32(new Bgra32(255, 255, 255, 255));
+            bgra2.FromBgra32(new Bgra32(255, 0, 255, 255));
+
+            // assert
+            Assert.Equal(expectedPackedValue1, bgra1.PackedValue);
+            Assert.Equal(expectedPackedValue2, bgra2.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra5551_FromArgb32()
+        {
+            // arrange
+            var bgra = default(Bgra5551);
+            ushort expectedPackedValue = ushort.MaxValue;
+            
+            // act
+            bgra.FromArgb32(new Argb32(255, 255, 255, 255));
+            
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra5551_FromRgba64()
+        {
+            // arrange
+            var bgra = default(Bgra5551);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra5551_FromGrey16()
+        {
+            // arrange
+            var bgra = default(Bgra5551);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromGray16(new Gray16(ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra5551_FromGrey8()
+        {
+            // arrange
+            var bgra = default(Bgra5551);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromGray8(new Gray8(byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra5551_FromBgr24()
+        {
+            // arrange
+            var bgra = default(Bgra5551);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra5551_FromRgb24()
+        {
+            // arrange
+            var bgra = default(Bgra5551);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
         [Fact]
         public void Bgra5551_Clamping()
         {

tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs

@@ -61,6 +61,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Byte4_FromBgra5551()
+        {
+            // arrange
+            var rgb = default(Byte4);
+            uint expected = 0xFFFFFFFF;
+
+            // act
+            rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, rgb.PackedValue);
+        }
+
         [Fact]
         public void Byte4_Clamping()
         {

tests/ImageSharp.Tests/PixelFormats/Gray16Tests.cs

@@ -126,5 +126,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual.B);
             Assert.Equal(byte.MaxValue, actual.A);
         }
+
+        [Fact]
+        public void Gray16_FromBgra5551()
+        {
+            // arrange
+            var gray = default(Gray16);
+            ushort expected = ushort.MaxValue;
+
+            // act
+            gray.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, gray.PackedValue);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Gray8Tests.cs

@@ -148,6 +148,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(byte.MaxValue, actual.A);
         }
 
+        [Fact]
+        public void Gray8_FromBgra5551()
+        {
+            // arrange
+            var grey = default(Gray8);
+            byte expected = byte.MaxValue;
+
+            // act
+            grey.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, grey.PackedValue);
+        }
+
         public class Rgba32Compatibility
         {
             // ReSharper disable once MemberHidesStaticFromOuterClass

tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs

@@ -71,5 +71,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void HalfVector2_FromBgra5551()
+        {
+            // arrange
+            var halfVector2 = default(HalfVector2);
+            
+            // act
+            halfVector2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Vector4 actual = halfVector2.ToScaledVector4();
+            Assert.Equal(1F, actual.X);
+            Assert.Equal(1F, actual.Y);
+            Assert.Equal(0, actual.Z);
+            Assert.Equal(1, actual.W);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs

@@ -65,5 +65,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void HalfVector4_FromBgra5551()
+        {
+            // arrange
+            var halfVector4 = default(HalfVector4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            halfVector4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, halfVector4.ToScaledVector4());
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs

@@ -66,5 +66,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void NormalizedByte2_FromBgra5551()
+        {
+            // arrange
+            var normalizedByte2 = default(NormalizedByte2);
+            var expected = new Vector4(1, 1, 0, 1);
+
+            // act
+            normalizedByte2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, normalizedByte2.ToVector4());
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs

@@ -60,5 +60,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void NormalizedByte4_FromBgra5551()
+        {
+            // arrange
+            var normalizedByte4 = default(NormalizedByte4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            normalizedByte4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, normalizedByte4.ToVector4());
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs

@@ -69,5 +69,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void NormalizedShort2_FromBgra5551()
+        {
+            // arrange
+            var normalizedShort2 = default(NormalizedShort2);
+            var expected = new Vector4(1, 1, 0, 1);
+
+            // act
+            normalizedShort2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, normalizedShort2.ToVector4());
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs

@@ -61,5 +61,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void NormalizedShort4_FromBgra5551()
+        {
+            // arrange
+            var normalizedShort4 = default(NormalizedShort4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            normalizedShort4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, normalizedShort4.ToVector4());
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs

@@ -62,6 +62,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Rg32_FromBgra5551()
+        {
+            // arrange
+            var rg32 = new Rg32(Vector2.One);
+            uint expected = 0xFFFFFFFF;
+
+            // act
+            rg32.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, rg32.PackedValue);
+        }
+
         [Fact]
         public void Rg32_Clamping()
         {

tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs

@@ -103,11 +103,31 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
         [Fact]
         public void ToRgba32()
         {
+            // arrange
             var rgb = new Rgb24(1, 2, 3);
             Rgba32 rgba = default;
+            var expected = new Rgba32(1, 2, 3, 255);
+
+            // act
             rgb.ToRgba32(ref rgba);
 
-            Assert.Equal(new Rgba32(1, 2, 3, 255), rgba);
+            // assert
+            Assert.Equal(expected, rgba);
+        }
+
+        [Fact]
+        public void Rgb24_FromBgra5551()
+        {
+            // arrange
+            var rgb = new Rgb24(255, 255, 255);
+
+            // act
+            rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(255, rgb.R);
+            Assert.Equal(255, rgb.G);
+            Assert.Equal(255, rgb.B);
         }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs

@@ -58,5 +58,21 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void Rgb48_FromBgra5551()
+        {
+            // arrange
+            var rgb = default(Rgb48);
+            ushort expected = ushort.MaxValue;
+
+            // act
+            rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, rgb.R);
+            Assert.Equal(expected, rgb.G);
+            Assert.Equal(expected, rgb.B);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs

@@ -64,6 +64,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual.PackedValue);
         }
 
+        [Fact]
+        public void Rgba1010102_FromBgra5551()
+        {
+            // arrange
+            var rgba = new Rgba1010102(Vector4.One);
+            uint expected = 0xFFFFFFFF;
+
+            // act
+            rgba.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, rgba.PackedValue);
+        }
+
         [Fact]
         public void Rgba1010102_Clamping()
         {

tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs

@@ -276,5 +276,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void Rgba32_FromBgra5551()
+        {
+            // arrange
+            var rgb = default(Rgba32);
+            uint expected = 0xFFFFFFFF;
+
+            // act
+            rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, rgb.PackedValue);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs

@@ -91,5 +91,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void Rgba64_FromBgra5551()
+        {
+            // arrange
+            var rgba = default(Rgba64);
+            ushort expected = ushort.MaxValue;
+
+            // act
+            rgba.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, rgba.R);
+            Assert.Equal(expected, rgba.G);
+            Assert.Equal(expected, rgba.B);
+            Assert.Equal(expected, rgba.A);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs

@@ -141,5 +141,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void Short2_FromBgra5551()
+        {
+            // arrange
+            var short2 = default(Short2);
+            
+            // act
+            short2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Vector4 actual = short2.ToScaledVector4();
+            Assert.Equal(1, actual.X);
+            Assert.Equal(1, actual.Y);
+            Assert.Equal(0, actual.Z);
+            Assert.Equal(1, actual.W);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs

@@ -181,5 +181,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void Short4_FromBgra5551()
+        {
+            // arrange
+            var short4 = default(Short4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            short4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, short4.ToScaledVector4());
+        }
     }
 }

tests/ImageSharp.Tests/TestImages.cs

@@ -241,6 +241,7 @@ namespace SixLabors.ImageSharp.Tests
             public const string Bit16Inverted = "Bmp/test16-inverted.bmp";
             public const string Bit32Rgb = "Bmp/rgb32.bmp";
             public const string Bit32Rgba = "Bmp/rgba32.bmp";
+            public const string Rgb16 = "Bmp/rgb16.bmp";
 
             // Note: This format can be called OS/2 BMPv1, or Windows BMPv2
             public const string WinBmpv2 = "Bmp/pal8os2v1_winv2.bmp";

tests/ImageSharp.Tests/TestUtilities/PixelTypes.cs

@@ -58,6 +58,8 @@ namespace SixLabors.ImageSharp.Tests
 
         Rgb48 = 1 << 21,
 
+        Bgra5551 = 1 << 22,
+
         // TODO: Add multi-flag entries by rules defined in PackedPixelConverterHelper
 
         // "All" is handled as a separate, individual case instead of using bitwise OR