diff --git a/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs b/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs
index 5700bb444c..3c9e3ce795 100644
--- a/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs
@@ -11,35 +11,35 @@ public enum BmpBitsPerPixel : short
///
/// 1 bit per pixel.
///
- Pixel1 = 1,
+ Bit1 = 1,
///
/// 2 bits per pixel.
///
- Pixel2 = 2,
+ Bit2 = 2,
///
/// 4 bits per pixel.
///
- Pixel4 = 4,
+ Bit4 = 4,
///
/// 8 bits per pixel. Each pixel consists of 1 byte.
///
- Pixel8 = 8,
+ Bit8 = 8,
///
/// 16 bits per pixel. Each pixel consists of 2 bytes.
///
- Pixel16 = 16,
+ Bit16 = 16,
///
/// 24 bits per pixel. Each pixel consists of 3 bytes.
///
- Pixel24 = 24,
+ Bit24 = 24,
///
/// 32 bits per pixel. Each pixel consists of 4 bytes.
///
- Pixel32 = 32
+ Bit32 = 32
}
diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
index 076d1adf00..24a4fa2f57 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -130,10 +130,10 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
int colorPaletteSize = this.bitsPerPixel switch
{
- BmpBitsPerPixel.Pixel8 => ColorPaletteSize8Bit,
- BmpBitsPerPixel.Pixel4 => ColorPaletteSize4Bit,
- BmpBitsPerPixel.Pixel2 => ColorPaletteSize2Bit,
- BmpBitsPerPixel.Pixel1 => ColorPaletteSize1Bit,
+ BmpBitsPerPixel.Bit8 => ColorPaletteSize8Bit,
+ BmpBitsPerPixel.Bit4 => ColorPaletteSize4Bit,
+ BmpBitsPerPixel.Bit2 => ColorPaletteSize2Bit,
+ BmpBitsPerPixel.Bit1 => ColorPaletteSize1Bit,
_ => 0
};
@@ -220,7 +220,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
clrUsed: 0,
clrImportant: 0);
- if ((this.infoHeaderType is BmpInfoHeaderType.WinVersion4 or BmpInfoHeaderType.WinVersion5) && this.bitsPerPixel == BmpBitsPerPixel.Pixel32)
+ if ((this.infoHeaderType is BmpInfoHeaderType.WinVersion4 or BmpInfoHeaderType.WinVersion5) && this.bitsPerPixel == BmpBitsPerPixel.Bit32)
{
infoHeader.AlphaMask = Rgba32AlphaMask;
infoHeader.RedMask = Rgba32RedMask;
@@ -319,31 +319,31 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
Buffer2D pixels = image.Frames.RootFrame.PixelBuffer;
switch (this.bitsPerPixel)
{
- case BmpBitsPerPixel.Pixel32:
+ case BmpBitsPerPixel.Bit32:
this.Write32BitPixelData(configuration, stream, pixels);
break;
- case BmpBitsPerPixel.Pixel24:
+ case BmpBitsPerPixel.Bit24:
this.Write24BitPixelData(configuration, stream, pixels);
break;
- case BmpBitsPerPixel.Pixel16:
+ case BmpBitsPerPixel.Bit16:
this.Write16BitPixelData(configuration, stream, pixels);
break;
- case BmpBitsPerPixel.Pixel8:
+ case BmpBitsPerPixel.Bit8:
this.Write8BitPixelData(configuration, stream, image);
break;
- case BmpBitsPerPixel.Pixel4:
+ case BmpBitsPerPixel.Bit4:
this.Write4BitPixelData(configuration, stream, image);
break;
- case BmpBitsPerPixel.Pixel2:
+ case BmpBitsPerPixel.Bit2:
this.Write2BitPixelData(configuration, stream, image);
break;
- case BmpBitsPerPixel.Pixel1:
+ case BmpBitsPerPixel.Bit1:
this.Write1BitPixelData(configuration, stream, image);
break;
}
diff --git a/src/ImageSharp/Formats/Bmp/BmpMetadata.cs b/src/ImageSharp/Formats/Bmp/BmpMetadata.cs
index d44520a4f3..bad47bd0d5 100644
--- a/src/ImageSharp/Formats/Bmp/BmpMetadata.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpMetadata.cs
@@ -36,7 +36,7 @@ public class BmpMetadata : IFormatMetadata, IFormatFrameMetadata
/// Gets or sets the number of bits per pixel.
///
- public BmpBitsPerPixel BitsPerPixel { get; set; } = BmpBitsPerPixel.Pixel24;
+ public BmpBitsPerPixel BitsPerPixel { get; set; } = BmpBitsPerPixel.Bit24;
///
public static BmpMetadata FromFormatConnectingMetadata(FormatConnectingMetadata metadata)
@@ -44,23 +44,23 @@ public class BmpMetadata : IFormatMetadata, IFormatFrameMetadata new BmpMetadata { BitsPerPixel = BmpBitsPerPixel.Pixel1 },
- 2 => new BmpMetadata { BitsPerPixel = BmpBitsPerPixel.Pixel2 },
- <= 4 => new BmpMetadata { BitsPerPixel = BmpBitsPerPixel.Pixel4 },
- <= 8 => new BmpMetadata { BitsPerPixel = BmpBitsPerPixel.Pixel8 },
+ 1 => new BmpMetadata { BitsPerPixel = BmpBitsPerPixel.Bit1 },
+ 2 => new BmpMetadata { BitsPerPixel = BmpBitsPerPixel.Bit2 },
+ <= 4 => new BmpMetadata { BitsPerPixel = BmpBitsPerPixel.Bit4 },
+ <= 8 => new BmpMetadata { BitsPerPixel = BmpBitsPerPixel.Bit8 },
<= 16 => new BmpMetadata
{
- BitsPerPixel = BmpBitsPerPixel.Pixel16,
+ BitsPerPixel = BmpBitsPerPixel.Bit16,
InfoHeaderType = BmpInfoHeaderType.WinVersion3
},
<= 24 => new BmpMetadata
{
- BitsPerPixel = BmpBitsPerPixel.Pixel24,
+ BitsPerPixel = BmpBitsPerPixel.Bit24,
InfoHeaderType = BmpInfoHeaderType.WinVersion4
},
_ => new BmpMetadata
{
- BitsPerPixel = BmpBitsPerPixel.Pixel32,
+ BitsPerPixel = BmpBitsPerPixel.Bit32,
InfoHeaderType = BmpInfoHeaderType.WinVersion5
}
};
@@ -92,34 +92,34 @@ public class BmpMetadata : IFormatMetadata, IFormatFrameMetadata
///
/// Initializes a new instance of the class.
///
- public JpegMetadata() => this.Comments = [];
+ public JpegMetadata()
+ {
+ }
///
/// Initializes a new instance of the class.
diff --git a/src/ImageSharp/Formats/Tga/TgaBitsPerPixel.cs b/src/ImageSharp/Formats/Tga/TgaBitsPerPixel.cs
index da34e62f7e..af537ddc21 100644
--- a/src/ImageSharp/Formats/Tga/TgaBitsPerPixel.cs
+++ b/src/ImageSharp/Formats/Tga/TgaBitsPerPixel.cs
@@ -11,20 +11,20 @@ public enum TgaBitsPerPixel : byte
///
/// 8 bits per pixel. Each pixel consists of 1 byte.
///
- Pixel8 = 8,
+ Bit8 = 8,
///
/// 16 bits per pixel. Each pixel consists of 2 bytes.
///
- Pixel16 = 16,
+ Bit16 = 16,
///
/// 24 bits per pixel. Each pixel consists of 3 bytes.
///
- Pixel24 = 24,
+ Bit24 = 24,
///
/// 32 bits per pixel. Each pixel consists of 4 bytes.
///
- Pixel32 = 32
+ Bit32 = 32
}
diff --git a/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs b/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
index b454c677bc..47f7eb0f2e 100644
--- a/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
+++ b/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
@@ -934,7 +934,7 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
return (TgaImageOrigin)((this.fileHeader.ImageDescriptor & 0x30) >> 4);
}
- private bool IsTrueColor32BitPerPixel(TgaBitsPerPixel bitsPerPixel) => bitsPerPixel == TgaBitsPerPixel.Pixel32 &&
+ private bool IsTrueColor32BitPerPixel(TgaBitsPerPixel bitsPerPixel) => bitsPerPixel == TgaBitsPerPixel.Bit32 &&
(this.fileHeader.ImageType == TgaImageType.TrueColor ||
this.fileHeader.ImageType == TgaImageType.RleTrueColor);
}
diff --git a/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs b/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
index 14351ee67c..8e13096568 100644
--- a/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
+++ b/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
@@ -59,7 +59,7 @@ internal sealed class TgaEncoderCore : IImageEncoderInternals
this.bitsPerPixel ??= tgaMetadata.BitsPerPixel;
TgaImageType imageType = this.compression is TgaCompression.RunLength ? TgaImageType.RleTrueColor : TgaImageType.TrueColor;
- if (this.bitsPerPixel == TgaBitsPerPixel.Pixel8)
+ if (this.bitsPerPixel == TgaBitsPerPixel.Bit8)
{
imageType = this.compression is TgaCompression.RunLength ? TgaImageType.RleBlackAndWhite : TgaImageType.BlackAndWhite;
}
@@ -71,13 +71,13 @@ internal sealed class TgaEncoderCore : IImageEncoderInternals
imageDescriptor |= 0x20;
}
- if (this.bitsPerPixel is TgaBitsPerPixel.Pixel32)
+ if (this.bitsPerPixel is TgaBitsPerPixel.Bit32)
{
// Indicate, that 8 bit are used for the alpha channel.
imageDescriptor |= 0x8;
}
- if (this.bitsPerPixel is TgaBitsPerPixel.Pixel16)
+ if (this.bitsPerPixel is TgaBitsPerPixel.Bit16)
{
// Indicate, that 1 bit is used for the alpha channel.
imageDescriptor |= 0x1;
@@ -130,19 +130,19 @@ internal sealed class TgaEncoderCore : IImageEncoderInternals
Buffer2D pixels = image.PixelBuffer;
switch (this.bitsPerPixel)
{
- case TgaBitsPerPixel.Pixel8:
+ case TgaBitsPerPixel.Bit8:
this.Write8Bit(configuration, stream, pixels);
break;
- case TgaBitsPerPixel.Pixel16:
+ case TgaBitsPerPixel.Bit16:
this.Write16Bit(configuration, stream, pixels);
break;
- case TgaBitsPerPixel.Pixel24:
+ case TgaBitsPerPixel.Bit24:
this.Write24Bit(configuration, stream, pixels);
break;
- case TgaBitsPerPixel.Pixel32:
+ case TgaBitsPerPixel.Bit32:
this.Write32Bit(configuration, stream, pixels);
break;
}
@@ -208,12 +208,12 @@ internal sealed class TgaEncoderCore : IImageEncoderInternals
{
switch (this.bitsPerPixel)
{
- case TgaBitsPerPixel.Pixel8:
+ case TgaBitsPerPixel.Bit8:
L8 l8 = L8.FromRgba32(color);
stream.WriteByte(l8.PackedValue);
break;
- case TgaBitsPerPixel.Pixel16:
+ case TgaBitsPerPixel.Bit16:
Bgra5551 bgra5551 = Bgra5551.FromRgba32(color);
Span buffer = stackalloc byte[2];
BinaryPrimitives.WriteInt16LittleEndian(buffer, (short)bgra5551.PackedValue);
@@ -222,13 +222,13 @@ internal sealed class TgaEncoderCore : IImageEncoderInternals
break;
- case TgaBitsPerPixel.Pixel24:
+ case TgaBitsPerPixel.Bit24:
stream.WriteByte(color.B);
stream.WriteByte(color.G);
stream.WriteByte(color.R);
break;
- case TgaBitsPerPixel.Pixel32:
+ case TgaBitsPerPixel.Bit32:
stream.WriteByte(color.B);
stream.WriteByte(color.G);
stream.WriteByte(color.R);
diff --git a/src/ImageSharp/Formats/Tga/TgaMetadata.cs b/src/ImageSharp/Formats/Tga/TgaMetadata.cs
index fa8e8b6f4f..58b5119523 100644
--- a/src/ImageSharp/Formats/Tga/TgaMetadata.cs
+++ b/src/ImageSharp/Formats/Tga/TgaMetadata.cs
@@ -27,7 +27,7 @@ public class TgaMetadata : IFormatMetadata
///
/// Gets or sets the number of bits per pixel.
///
- public TgaBitsPerPixel BitsPerPixel { get; set; } = TgaBitsPerPixel.Pixel24;
+ public TgaBitsPerPixel BitsPerPixel { get; set; } = TgaBitsPerPixel.Bit24;
///
/// Gets or sets the number of alpha bits per pixel.
@@ -41,10 +41,10 @@ public class TgaMetadata : IFormatMetadata
int bpp = metadata.PixelTypeInfo.BitsPerPixel;
return bpp switch
{
- <= 8 => new TgaMetadata { BitsPerPixel = TgaBitsPerPixel.Pixel8 },
- <= 16 => new TgaMetadata { BitsPerPixel = TgaBitsPerPixel.Pixel16 },
- <= 24 => new TgaMetadata { BitsPerPixel = TgaBitsPerPixel.Pixel24 },
- _ => new TgaMetadata { BitsPerPixel = TgaBitsPerPixel.Pixel32 }
+ <= 8 => new TgaMetadata { BitsPerPixel = TgaBitsPerPixel.Bit8 },
+ <= 16 => new TgaMetadata { BitsPerPixel = TgaBitsPerPixel.Bit16 },
+ <= 24 => new TgaMetadata { BitsPerPixel = TgaBitsPerPixel.Bit24 },
+ _ => new TgaMetadata { BitsPerPixel = TgaBitsPerPixel.Bit32 }
};
}
@@ -57,22 +57,22 @@ public class TgaMetadata : IFormatMetadata
PixelAlphaRepresentation alpha;
switch (this.BitsPerPixel)
{
- case TgaBitsPerPixel.Pixel8:
+ case TgaBitsPerPixel.Bit8:
info = PixelComponentInfo.Create(1, bpp, 8);
color = PixelColorType.Luminance;
alpha = PixelAlphaRepresentation.None;
break;
- case TgaBitsPerPixel.Pixel16:
+ case TgaBitsPerPixel.Bit16:
info = PixelComponentInfo.Create(1, bpp, 5, 5, 5, 1);
color = PixelColorType.BGR | PixelColorType.Alpha;
alpha = PixelAlphaRepresentation.Unassociated;
break;
- case TgaBitsPerPixel.Pixel24:
+ case TgaBitsPerPixel.Bit24:
info = PixelComponentInfo.Create(3, bpp, 8, 8, 8);
color = PixelColorType.RGB;
alpha = PixelAlphaRepresentation.None;
break;
- case TgaBitsPerPixel.Pixel32 or _:
+ case TgaBitsPerPixel.Bit32 or _:
info = PixelComponentInfo.Create(4, bpp, 8, 8, 8, 8);
color = PixelColorType.RGB | PixelColorType.Alpha;
alpha = PixelAlphaRepresentation.Unassociated;
diff --git a/src/ImageSharp/Formats/Webp/WebpBitsPerPixel.cs b/src/ImageSharp/Formats/Webp/WebpBitsPerPixel.cs
index 529c4bafb9..03717d852a 100644
--- a/src/ImageSharp/Formats/Webp/WebpBitsPerPixel.cs
+++ b/src/ImageSharp/Formats/Webp/WebpBitsPerPixel.cs
@@ -11,10 +11,10 @@ public enum WebpBitsPerPixel : short
///
/// 24 bits per pixel. Each pixel consists of 3 bytes.
///
- Pixel24 = 24,
+ Bit24 = 24,
///
/// 32 bits per pixel. Each pixel consists of 4 bytes (an alpha channel is present).
///
- Pixel32 = 32
+ Bit32 = 32
}
diff --git a/src/ImageSharp/Formats/Webp/WebpChunkParsingUtils.cs b/src/ImageSharp/Formats/Webp/WebpChunkParsingUtils.cs
index 07f09d45ea..4ccaf65031 100644
--- a/src/ImageSharp/Formats/Webp/WebpChunkParsingUtils.cs
+++ b/src/ImageSharp/Formats/Webp/WebpChunkParsingUtils.cs
@@ -17,6 +17,10 @@ internal static class WebpChunkParsingUtils
///
/// Reads the header of a lossy webp image.
///
+ /// The memory allocator.
+ /// The buffered read stream.
+ /// The scratch buffer to use while reading.
+ /// The webp features to parse.
/// Information about this webp image.
public static WebpImageInfo ReadVp8Header(MemoryAllocator memoryAllocator, BufferedReadStream stream, Span buffer, WebpFeatures features)
{
@@ -114,13 +118,15 @@ internal static class WebpChunkParsingUtils
Vp8BitReader bitReader = new(stream, remaining, memoryAllocator, partitionLength) { Remaining = remaining };
- return new WebpImageInfo
+ return new()
{
Width = width,
Height = height,
XScale = xScale,
YScale = yScale,
- BitsPerPixel = features?.Alpha == true ? WebpBitsPerPixel.Pixel32 : WebpBitsPerPixel.Pixel24,
+
+ // Vp8 header can be parsed during the processing of the Vp8X header.
+ BitsPerPixel = features?.Alpha == true ? WebpBitsPerPixel.Bit32 : WebpBitsPerPixel.Bit24,
IsLossless = false,
Features = features,
Vp8Profile = (sbyte)version,
@@ -132,7 +138,10 @@ internal static class WebpChunkParsingUtils
///
/// Reads the header of a lossless webp image.
///
- /// Information about this image.
+ /// The memory allocator.
+ /// The buffered read stream.
+ /// The scratch buffer to use while reading.
+ /// The webp features to parse.
public static WebpImageInfo ReadVp8LHeader(MemoryAllocator memoryAllocator, BufferedReadStream stream, Span buffer, WebpFeatures features)
{
// VP8 data size.
@@ -156,8 +165,8 @@ internal static class WebpChunkParsingUtils
}
// The alphaIsUsed flag should be set to 0 when all alpha values are 255 in the picture, and 1 otherwise.
- // TODO: this flag value is not used yet
- bool alphaIsUsed = bitReader.ReadBit();
+ // Alpha may have already been set by the VP8X chunk.
+ features.Alpha |= bitReader.ReadBit();
// The next 3 bits are the version. The version number is a 3 bit code that must be set to 0.
// Any other value should be treated as an error.
@@ -167,11 +176,11 @@ internal static class WebpChunkParsingUtils
WebpThrowHelper.ThrowNotSupportedException($"Unexpected version number {version} found in VP8L header");
}
- return new WebpImageInfo
+ return new()
{
Width = width,
Height = height,
- BitsPerPixel = WebpBitsPerPixel.Pixel32,
+ BitsPerPixel = features.Alpha ? WebpBitsPerPixel.Bit32 : WebpBitsPerPixel.Bit24,
IsLossless = true,
Features = features,
Vp8LBitReader = bitReader
@@ -187,6 +196,9 @@ internal static class WebpChunkParsingUtils
/// - An optional 'ALPH' chunk with alpha channel data.
/// After the image header, image data will follow. After that optional image metadata chunks (EXIF and XMP) can follow.
///
+ /// The buffered read stream.
+ /// The scratch buffer to use while reading.
+ /// The webp features to parse.
/// Information about this webp image.
public static WebpImageInfo ReadVp8XHeader(BufferedReadStream stream, Span buffer, WebpFeatures features)
{
@@ -217,11 +229,8 @@ internal static class WebpChunkParsingUtils
features.Animation = (imageFeatures & (1 << 1)) != 0;
// 3 reserved bytes should follow which are supposed to be zero.
+ // No other decoder actually checks this though.
stream.Read(buffer, 0, 3);
- if (buffer[0] != 0 || buffer[1] != 0 || buffer[2] != 0)
- {
- WebpThrowHelper.ThrowImageFormatException("reserved bytes should be zero");
- }
// 3 bytes for the width.
uint width = ReadUInt24LittleEndian(stream, buffer) + 1;
@@ -230,14 +239,14 @@ internal static class WebpChunkParsingUtils
uint height = ReadUInt24LittleEndian(stream, buffer) + 1;
// Read all the chunks in the order they occur.
- WebpImageInfo info = new()
+ return new()
{
Width = width,
Height = height,
Features = features
- };
- return info;
+ // Additional properties are set during the parsing of the VP8 or VP8L headers.
+ };
}
///
diff --git a/src/ImageSharp/Formats/Webp/WebpColorType.cs b/src/ImageSharp/Formats/Webp/WebpColorType.cs
new file mode 100644
index 0000000000..64d9143b1f
--- /dev/null
+++ b/src/ImageSharp/Formats/Webp/WebpColorType.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Webp;
+
+///
+/// Provides enumeration of the various webp color types.
+///
+public enum WebpColorType
+{
+ ///
+ /// Yuv (luminance, blue chroma, red chroma) as defined in the ITU-R Rec. BT.709 specification.
+ ///
+ Yuv,
+
+ ///
+ /// Rgb color space.
+ ///
+ Rgb,
+
+ ///
+ /// Rgba color space.
+ ///
+ Rgba
+}
diff --git a/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs b/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
index 21f0f4946b..c29742da5b 100644
--- a/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
@@ -186,36 +186,43 @@ internal sealed class WebpDecoderCore : IImageDecoderInternals, IDisposable
Span buffer = stackalloc byte[4];
WebpChunkType chunkType = WebpChunkParsingUtils.ReadChunkType(stream, buffer);
+ WebpImageInfo? info = null;
WebpFeatures features = new();
switch (chunkType)
{
case WebpChunkType.Vp8:
+ info = WebpChunkParsingUtils.ReadVp8Header(this.memoryAllocator, stream, buffer, features);
webpMetadata.FileFormat = WebpFileFormatType.Lossy;
- return WebpChunkParsingUtils.ReadVp8Header(this.memoryAllocator, stream, buffer, features);
+ webpMetadata.ColorType = WebpColorType.Yuv;
+ return info;
case WebpChunkType.Vp8L:
+ info = WebpChunkParsingUtils.ReadVp8LHeader(this.memoryAllocator, stream, buffer, features);
webpMetadata.FileFormat = WebpFileFormatType.Lossless;
- return WebpChunkParsingUtils.ReadVp8LHeader(this.memoryAllocator, stream, buffer, features);
+ webpMetadata.ColorType = info.Features?.Alpha == true ? WebpColorType.Rgba : WebpColorType.Rgb;
+ return info;
case WebpChunkType.Vp8X:
- WebpImageInfo webpInfos = WebpChunkParsingUtils.ReadVp8XHeader(stream, buffer, features);
+ info = WebpChunkParsingUtils.ReadVp8XHeader(stream, buffer, features);
while (stream.Position < stream.Length)
{
chunkType = WebpChunkParsingUtils.ReadChunkType(stream, buffer);
if (chunkType == WebpChunkType.Vp8)
{
+ info = WebpChunkParsingUtils.ReadVp8Header(this.memoryAllocator, stream, buffer, features);
webpMetadata.FileFormat = WebpFileFormatType.Lossy;
- webpInfos = WebpChunkParsingUtils.ReadVp8Header(this.memoryAllocator, stream, buffer, features);
+ webpMetadata.ColorType = info.Features?.Alpha == true ? WebpColorType.Rgba : WebpColorType.Rgb;
}
else if (chunkType == WebpChunkType.Vp8L)
{
+ info = WebpChunkParsingUtils.ReadVp8LHeader(this.memoryAllocator, stream, buffer, features);
webpMetadata.FileFormat = WebpFileFormatType.Lossless;
- webpInfos = WebpChunkParsingUtils.ReadVp8LHeader(this.memoryAllocator, stream, buffer, features);
+ webpMetadata.ColorType = info.Features?.Alpha == true ? WebpColorType.Rgba : WebpColorType.Rgb;
}
else if (WebpChunkParsingUtils.IsOptionalVp8XChunk(chunkType))
{
bool isAnimationChunk = this.ParseOptionalExtendedChunks(stream, metadata, chunkType, features, ignoreAlpha, buffer);
if (isAnimationChunk)
{
- return webpInfos;
+ return info;
}
}
else
@@ -226,7 +233,7 @@ internal sealed class WebpDecoderCore : IImageDecoderInternals, IDisposable
}
}
- return webpInfos;
+ return info;
default:
WebpThrowHelper.ThrowImageFormatException("Unrecognized VP8 header");
return
diff --git a/src/ImageSharp/Formats/Webp/WebpImageInfo.cs b/src/ImageSharp/Formats/Webp/WebpImageInfo.cs
index 5f7301b262..3428ce199a 100644
--- a/src/ImageSharp/Formats/Webp/WebpImageInfo.cs
+++ b/src/ImageSharp/Formats/Webp/WebpImageInfo.cs
@@ -18,8 +18,14 @@ internal class WebpImageInfo : IDisposable
///
public uint Height { get; set; }
+ ///
+ /// Gets or sets the horizontal scale.
+ ///
public sbyte XScale { get; set; }
+ ///
+ /// Gets or sets the vertical scale.
+ ///
public sbyte YScale { get; set; }
///
diff --git a/src/ImageSharp/Formats/Webp/WebpMetadata.cs b/src/ImageSharp/Formats/Webp/WebpMetadata.cs
index 536ea09294..d8cd29d142 100644
--- a/src/ImageSharp/Formats/Webp/WebpMetadata.cs
+++ b/src/ImageSharp/Formats/Webp/WebpMetadata.cs
@@ -6,7 +6,7 @@ namespace SixLabors.ImageSharp.Formats.Webp;
///
/// Provides Webp specific metadata information for the image.
///
-public class WebpMetadata : IDeepCloneable
+public class WebpMetadata : IFormatFrameMetadata
{
///
/// Initializes a new instance of the class.
@@ -21,15 +21,27 @@ public class WebpMetadata : IDeepCloneable
/// The metadata to create an instance from.
private WebpMetadata(WebpMetadata other)
{
+ this.BitsPerPixel = other.BitsPerPixel;
+ this.ColorType = other.ColorType;
this.FileFormat = other.FileFormat;
this.RepeatCount = other.RepeatCount;
this.BackgroundColor = other.BackgroundColor;
}
+ ///
+ /// Gets or sets the number of bits per pixel.
+ ///
+ public WebpBitsPerPixel BitsPerPixel { get; set; } = WebpBitsPerPixel.Bit32;
+
+ ///
+ /// Gets or sets the color type.
+ ///
+ public WebpColorType ColorType { get; set; } = WebpColorType.Rgba;
+
///
/// Gets or sets the webp file format used. Either lossless or lossy.
///
- public WebpFileFormatType? FileFormat { get; set; }
+ public WebpFileFormatType FileFormat { get; set; } = WebpFileFormatType.Lossless;
///
/// Gets or sets the loop count. The number of times to loop the animation. 0 means infinitely.
@@ -44,9 +56,6 @@ public class WebpMetadata : IDeepCloneable
///
public Color BackgroundColor { get; set; }
- ///
- public IDeepCloneable DeepClone() => new WebpMetadata(this);
-
internal static WebpMetadata FromAnimatedMetadata(AnimatedImageMetadata metadata)
=> new()
{
@@ -54,4 +63,18 @@ public class WebpMetadata : IDeepCloneable
BackgroundColor = metadata.BackgroundColor,
RepeatCount = metadata.RepeatCount
};
+
+ ///
+ public static WebpMetadata FromFormatConnectingFrameMetadata(FormatConnectingFrameMetadata metadata)
+ => throw new NotImplementedException();
+
+ ///
+ public FormatConnectingFrameMetadata ToFormatConnectingFrameMetadata()
+ => throw new NotImplementedException();
+
+ ///
+ IDeepCloneable IDeepCloneable.DeepClone() => this.DeepClone();
+
+ ///
+ public WebpMetadata DeepClone() => new(this);
}
diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
index 42cbd90f3b..a0fbc210f8 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
@@ -22,8 +22,8 @@ public class BmpEncoderTests
public static readonly TheoryData BitsPerPixel =
new()
{
- BmpBitsPerPixel.Pixel24,
- BmpBitsPerPixel.Pixel32
+ BmpBitsPerPixel.Bit24,
+ BmpBitsPerPixel.Bit32
};
public static readonly TheoryData RatioFiles =
@@ -37,13 +37,13 @@ public class BmpEncoderTests
public static readonly TheoryData BmpBitsPerPixelFiles =
new()
{
- { Bit1, BmpBitsPerPixel.Pixel1 },
- { Bit2, BmpBitsPerPixel.Pixel2 },
- { Bit4, BmpBitsPerPixel.Pixel4 },
- { Bit8, BmpBitsPerPixel.Pixel8 },
- { Rgb16, BmpBitsPerPixel.Pixel16 },
- { Car, BmpBitsPerPixel.Pixel24 },
- { Bit32Rgb, BmpBitsPerPixel.Pixel32 }
+ { Bit1, BmpBitsPerPixel.Bit1 },
+ { Bit2, BmpBitsPerPixel.Bit2 },
+ { Bit4, BmpBitsPerPixel.Bit4 },
+ { Bit8, BmpBitsPerPixel.Bit8 },
+ { Rgb16, BmpBitsPerPixel.Bit16 },
+ { Car, BmpBitsPerPixel.Bit24 },
+ { Bit32Rgb, BmpBitsPerPixel.Bit32 }
};
[Fact]
@@ -97,61 +97,61 @@ public class BmpEncoderTests
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel);
[Theory]
- [WithFile(Bit32Rgb, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
- [WithFile(Bit32Rgba, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
- [WithFile(WinBmpv4, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
- [WithFile(WinBmpv5, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
+ [WithFile(Bit32Rgb, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Bit32)]
+ [WithFile(Bit32Rgba, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Bit32)]
+ [WithFile(WinBmpv4, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Bit32)]
+ [WithFile(WinBmpv5, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Bit32)]
public void Encode_32Bit_WithV3Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
// If supportTransparency is false, a v3 bitmap header will be written.
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
[Theory]
- [WithFile(Bit32Rgb, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
- [WithFile(Bit32Rgba, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
- [WithFile(WinBmpv4, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
- [WithFile(WinBmpv5, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Pixel32)]
+ [WithFile(Bit32Rgb, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Bit32)]
+ [WithFile(Bit32Rgba, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Bit32)]
+ [WithFile(WinBmpv4, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Bit32)]
+ [WithFile(WinBmpv5, PixelTypes.Rgba32 | PixelTypes.Rgb24, BmpBitsPerPixel.Bit32)]
public void Encode_32Bit_WithV4Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
[Theory]
- [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)] // WinBmpv3 is a 24 bits per pixel image.
- [WithFile(F, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
+ [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Bit24)] // WinBmpv3 is a 24 bits per pixel image.
+ [WithFile(F, PixelTypes.Rgb24, BmpBitsPerPixel.Bit24)]
public void Encode_24Bit_WithV3Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
[Theory]
- [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
- [WithFile(F, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel24)]
+ [WithFile(WinBmpv3, PixelTypes.Rgb24, BmpBitsPerPixel.Bit24)]
+ [WithFile(F, PixelTypes.Rgb24, BmpBitsPerPixel.Bit24)]
public void Encode_24Bit_WithV4Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
[Theory]
- [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
- [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
+ [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Bit16)]
+ [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Bit16)]
public void Encode_16Bit_WithV3Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
[Theory]
- [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
- [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Pixel16)]
+ [WithFile(Rgb16, PixelTypes.Bgra5551, BmpBitsPerPixel.Bit16)]
+ [WithFile(Bit16, PixelTypes.Bgra5551, BmpBitsPerPixel.Bit16)]
public void Encode_16Bit_WithV4Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
[Theory]
- [WithFile(WinBmpv5, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
- [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
+ [WithFile(WinBmpv5, PixelTypes.Rgba32, BmpBitsPerPixel.Bit8)]
+ [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Bit8)]
public void Encode_8Bit_WithV3Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
[Theory]
- [WithFile(WinBmpv5, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
- [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel8)]
+ [WithFile(WinBmpv5, PixelTypes.Rgba32, BmpBitsPerPixel.Bit8)]
+ [WithFile(Bit8Palette4, PixelTypes.Rgba32, BmpBitsPerPixel.Bit8)]
public void Encode_8Bit_WithV4Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
[Theory]
- [WithFile(Bit8Gs, PixelTypes.L8, BmpBitsPerPixel.Pixel8)]
+ [WithFile(Bit8Gs, PixelTypes.L8, BmpBitsPerPixel.Bit8)]
public void Encode_8BitGray_WithV3Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel =>
TestBmpEncoderCore(
@@ -160,7 +160,7 @@ public class BmpEncoderTests
supportTransparency: false);
[Theory]
- [WithFile(Bit4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel4)]
+ [WithFile(Bit4, PixelTypes.Rgba32, BmpBitsPerPixel.Bit4)]
public void Encode_4Bit_WithV3Header_Works(
TestImageProvider provider,
BmpBitsPerPixel bitsPerPixel)
@@ -176,7 +176,7 @@ public class BmpEncoderTests
}
[Theory]
- [WithFile(Bit4, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel4)]
+ [WithFile(Bit4, PixelTypes.Rgba32, BmpBitsPerPixel.Bit4)]
public void Encode_4Bit_WithV4Header_Works(
TestImageProvider provider,
BmpBitsPerPixel bitsPerPixel)
@@ -192,7 +192,7 @@ public class BmpEncoderTests
}
[Theory]
- [WithFile(Bit2, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel2)]
+ [WithFile(Bit2, PixelTypes.Rgba32, BmpBitsPerPixel.Bit2)]
public void Encode_2Bit_WithV3Header_Works(
TestImageProvider provider,
BmpBitsPerPixel bitsPerPixel)
@@ -214,7 +214,7 @@ public class BmpEncoderTests
}
[Theory]
- [WithFile(Bit2, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel2)]
+ [WithFile(Bit2, PixelTypes.Rgba32, BmpBitsPerPixel.Bit2)]
public void Encode_2Bit_WithV4Header_Works(
TestImageProvider provider,
BmpBitsPerPixel bitsPerPixel)
@@ -236,21 +236,21 @@ public class BmpEncoderTests
}
[Theory]
- [WithFile(Bit1, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel1)]
+ [WithFile(Bit1, PixelTypes.Rgba32, BmpBitsPerPixel.Bit1)]
public void Encode_1Bit_WithV3Header_Works(
TestImageProvider provider,
BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: false);
[Theory]
- [WithFile(Bit1, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel1)]
+ [WithFile(Bit1, PixelTypes.Rgba32, BmpBitsPerPixel.Bit1)]
public void Encode_1Bit_WithV4Header_Works(
TestImageProvider provider,
BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
[Theory]
- [WithFile(Bit8Gs, PixelTypes.L8, BmpBitsPerPixel.Pixel8)]
+ [WithFile(Bit8Gs, PixelTypes.L8, BmpBitsPerPixel.Bit8)]
public void Encode_8BitGray_WithV4Header_Works(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel =>
TestBmpEncoderCore(
@@ -271,7 +271,7 @@ public class BmpEncoderTests
using Image image = provider.GetImage();
BmpEncoder encoder = new()
{
- BitsPerPixel = BmpBitsPerPixel.Pixel8,
+ BitsPerPixel = BmpBitsPerPixel.Bit8,
Quantizer = new WuQuantizer()
};
@@ -303,7 +303,7 @@ public class BmpEncoderTests
using Image image = provider.GetImage();
BmpEncoder encoder = new()
{
- BitsPerPixel = BmpBitsPerPixel.Pixel8,
+ BitsPerPixel = BmpBitsPerPixel.Bit8,
Quantizer = new OctreeQuantizer()
};
string actualOutputFile = provider.Utility.SaveTestOutputFile(image, "bmp", encoder, appendPixelTypeToFileName: false);
@@ -322,8 +322,8 @@ public class BmpEncoderTests
}
[Theory]
- [WithFile(TestImages.Png.GrayAlpha2BitInterlaced, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
- [WithFile(Bit32Rgba, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
+ [WithFile(TestImages.Png.GrayAlpha2BitInterlaced, PixelTypes.Rgba32, BmpBitsPerPixel.Bit32)]
+ [WithFile(Bit32Rgba, PixelTypes.Rgba32, BmpBitsPerPixel.Bit32)]
public void Encode_PreservesAlpha(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel => TestBmpEncoderCore(provider, bitsPerPixel, supportTransparency: true);
@@ -364,8 +364,8 @@ public class BmpEncoderTests
}
[Theory]
- [WithFile(Car, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
- [WithFile(V5Header, PixelTypes.Rgba32, BmpBitsPerPixel.Pixel32)]
+ [WithFile(Car, PixelTypes.Rgba32, BmpBitsPerPixel.Bit32)]
+ [WithFile(V5Header, PixelTypes.Rgba32, BmpBitsPerPixel.Bit32)]
public void Encode_WorksWithDiscontiguousBuffers(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel
{
@@ -374,7 +374,7 @@ public class BmpEncoderTests
}
[Theory]
- [WithFile(BlackWhitePalletDataMatrix, PixelTypes.Rgb24, BmpBitsPerPixel.Pixel1)]
+ [WithFile(BlackWhitePalletDataMatrix, PixelTypes.Rgb24, BmpBitsPerPixel.Bit1)]
public void Encode_Issue2467(TestImageProvider provider, BmpBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel
{
@@ -409,7 +409,7 @@ public class BmpEncoderTests
using Image image = provider.GetImage();
// There is no alpha in bmp with less then 32 bits per pixels, so the reference image will be made opaque.
- if (bitsPerPixel != BmpBitsPerPixel.Pixel32)
+ if (bitsPerPixel != BmpBitsPerPixel.Bit32)
{
image.Mutate(c => c.MakeOpaque());
}
diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpMetadataTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpMetadataTests.cs
index 1d84356713..f7a398ec14 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpMetadataTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpMetadataTests.cs
@@ -15,10 +15,10 @@ public class BmpMetadataTests
public void CloneIsDeep()
{
BmpMetadata meta = new()
- { BitsPerPixel = BmpBitsPerPixel.Pixel24, InfoHeaderType = BmpInfoHeaderType.Os2Version2 };
+ { BitsPerPixel = BmpBitsPerPixel.Bit24, InfoHeaderType = BmpInfoHeaderType.Os2Version2 };
BmpMetadata clone = (BmpMetadata)meta.DeepClone();
- clone.BitsPerPixel = BmpBitsPerPixel.Pixel32;
+ clone.BitsPerPixel = BmpBitsPerPixel.Bit32;
clone.InfoHeaderType = BmpInfoHeaderType.WinVersion2;
Assert.False(meta.BitsPerPixel.Equals(clone.BitsPerPixel));
diff --git a/tests/ImageSharp.Tests/Formats/Tga/TgaEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Tga/TgaEncoderTests.cs
index a3fa082c62..c9f93446f4 100644
--- a/tests/ImageSharp.Tests/Formats/Tga/TgaEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tga/TgaEncoderTests.cs
@@ -15,17 +15,17 @@ public class TgaEncoderTests
public static readonly TheoryData BitsPerPixel =
new()
{
- TgaBitsPerPixel.Pixel24,
- TgaBitsPerPixel.Pixel32
+ TgaBitsPerPixel.Bit24,
+ TgaBitsPerPixel.Bit32
};
public static readonly TheoryData TgaBitsPerPixelFiles =
new()
{
- { Gray8BitBottomLeft, TgaBitsPerPixel.Pixel8 },
- { Bit16BottomLeft, TgaBitsPerPixel.Pixel16 },
- { Bit24BottomLeft, TgaBitsPerPixel.Pixel24 },
- { Bit32BottomLeft, TgaBitsPerPixel.Pixel32 },
+ { Gray8BitBottomLeft, TgaBitsPerPixel.Bit8 },
+ { Bit16BottomLeft, TgaBitsPerPixel.Bit16 },
+ { Bit24BottomLeft, TgaBitsPerPixel.Bit24 },
+ { Bit32BottomLeft, TgaBitsPerPixel.Bit32 },
};
[Theory]
@@ -73,46 +73,46 @@ public class TgaEncoderTests
[Theory]
[WithFile(Bit32BottomLeft, PixelTypes.Rgba32)]
- public void TgaEncoder_Bit8_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Pixel8)
+ public void TgaEncoder_Bit8_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Bit8)
// Using tolerant comparer here. The results from magick differ slightly. Maybe a different ToGrey method is used. The image looks otherwise ok.
where TPixel : unmanaged, IPixel => TestTgaEncoderCore(provider, bitsPerPixel, TgaCompression.None, useExactComparer: false, compareTolerance: 0.03f);
[Theory]
[WithFile(Bit32BottomLeft, PixelTypes.Rgba32)]
- public void TgaEncoder_Bit16_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Pixel16)
+ public void TgaEncoder_Bit16_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Bit16)
where TPixel : unmanaged, IPixel => TestTgaEncoderCore(provider, bitsPerPixel, TgaCompression.None, useExactComparer: false);
[Theory]
[WithFile(Bit32BottomLeft, PixelTypes.Rgba32)]
- public void TgaEncoder_Bit24_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Pixel24)
+ public void TgaEncoder_Bit24_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Bit24)
where TPixel : unmanaged, IPixel => TestTgaEncoderCore(provider, bitsPerPixel, TgaCompression.None);
[Theory]
[WithFile(Bit32BottomLeft, PixelTypes.Rgba32)]
- public void TgaEncoder_Bit32_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Pixel32)
+ public void TgaEncoder_Bit32_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Bit32)
where TPixel : unmanaged, IPixel => TestTgaEncoderCore(provider, bitsPerPixel, TgaCompression.None);
[Theory]
[WithFile(Bit32BottomLeft, PixelTypes.Rgba32)]
- public void TgaEncoder_Bit8_WithRunLengthEncoding_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Pixel8)
+ public void TgaEncoder_Bit8_WithRunLengthEncoding_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Bit8)
// Using tolerant comparer here. The results from magick differ slightly. Maybe a different ToGrey method is used. The image looks otherwise ok.
where TPixel : unmanaged, IPixel => TestTgaEncoderCore(provider, bitsPerPixel, TgaCompression.RunLength, useExactComparer: false, compareTolerance: 0.03f);
[Theory]
[WithFile(Bit32BottomLeft, PixelTypes.Rgba32)]
- public void TgaEncoder_Bit16_WithRunLengthEncoding_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Pixel16)
+ public void TgaEncoder_Bit16_WithRunLengthEncoding_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Bit16)
where TPixel : unmanaged, IPixel => TestTgaEncoderCore(provider, bitsPerPixel, TgaCompression.RunLength, useExactComparer: false);
[Theory]
[WithFile(Bit32BottomLeft, PixelTypes.Rgba32)]
- public void TgaEncoder_Bit24_WithRunLengthEncoding_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Pixel24)
+ public void TgaEncoder_Bit24_WithRunLengthEncoding_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Bit24)
where TPixel : unmanaged, IPixel => TestTgaEncoderCore(provider, bitsPerPixel, TgaCompression.RunLength);
[Theory]
[WithFile(Bit32BottomLeft, PixelTypes.Rgba32)]
- public void TgaEncoder_Bit32_WithRunLengthEncoding_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Pixel32)
+ public void TgaEncoder_Bit32_WithRunLengthEncoding_Works(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel = TgaBitsPerPixel.Bit32)
where TPixel : unmanaged, IPixel => TestTgaEncoderCore(provider, bitsPerPixel, TgaCompression.RunLength);
[Theory]
@@ -152,8 +152,8 @@ public class TgaEncoderTests
}
[Theory]
- [WithFile(Bit32BottomLeft, PixelTypes.Rgba32, TgaBitsPerPixel.Pixel32)]
- [WithFile(Bit24BottomLeft, PixelTypes.Rgba32, TgaBitsPerPixel.Pixel24)]
+ [WithFile(Bit32BottomLeft, PixelTypes.Rgba32, TgaBitsPerPixel.Bit32)]
+ [WithFile(Bit24BottomLeft, PixelTypes.Rgba32, TgaBitsPerPixel.Bit24)]
public void TgaEncoder_WorksWithDiscontiguousBuffers(TestImageProvider provider, TgaBitsPerPixel bitsPerPixel)
where TPixel : unmanaged, IPixel
{
diff --git a/tests/ImageSharp.Tests/Formats/Tga/TgaFileHeaderTests.cs b/tests/ImageSharp.Tests/Formats/Tga/TgaFileHeaderTests.cs
index bf24ba3500..e5954719af 100644
--- a/tests/ImageSharp.Tests/Formats/Tga/TgaFileHeaderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tga/TgaFileHeaderTests.cs
@@ -33,10 +33,10 @@ public class TgaFileHeaderTests
}
[Theory]
- [InlineData(new byte[] { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 250, 0, 195, 0, 32, 8 }, 250, 195, TgaBitsPerPixel.Pixel32)]
- [InlineData(new byte[] { 26, 1, 9, 0, 0, 0, 1, 16, 0, 0, 0, 0, 128, 0, 128, 0, 8, 0 }, 128, 128, TgaBitsPerPixel.Pixel8)]
- [InlineData(new byte[] { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 220, 0, 220, 0, 16, 0 }, 220, 220, TgaBitsPerPixel.Pixel16)]
- [InlineData(new byte[] { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 124, 0, 124, 0, 24, 32 }, 124, 124, TgaBitsPerPixel.Pixel24)]
+ [InlineData(new byte[] { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 250, 0, 195, 0, 32, 8 }, 250, 195, TgaBitsPerPixel.Bit32)]
+ [InlineData(new byte[] { 26, 1, 9, 0, 0, 0, 1, 16, 0, 0, 0, 0, 128, 0, 128, 0, 8, 0 }, 128, 128, TgaBitsPerPixel.Bit8)]
+ [InlineData(new byte[] { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 220, 0, 220, 0, 16, 0 }, 220, 220, TgaBitsPerPixel.Bit16)]
+ [InlineData(new byte[] { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 124, 0, 124, 0, 24, 32 }, 124, 124, TgaBitsPerPixel.Bit24)]
public void Identify_WithValidData_Works(byte[] data, int width, int height, TgaBitsPerPixel bitsPerPixel)
{
using MemoryStream stream = new(data);
diff --git a/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs b/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs
index 0dda304b64..99f4dee168 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs
@@ -30,8 +30,8 @@ public class WebpDecoderTests
[Theory]
[InlineData(Lossless.GreenTransform1, 1000, 307, 32)]
- [InlineData(Lossless.BikeThreeTransforms, 250, 195, 32)]
- [InlineData(Lossless.NoTransform2, 128, 128, 32)]
+ [InlineData(Lossless.BikeThreeTransforms, 250, 195, 24)]
+ [InlineData(Lossless.NoTransform2, 128, 128, 24)]
[InlineData(Lossy.Alpha1, 1000, 307, 32)]
[InlineData(Lossy.Alpha2, 1000, 307, 32)]
[InlineData(Lossy.BikeWithExif, 250, 195, 24)]