Skip to content

Commit 9764802

Browse files
NominomNominom
committed
Add separate ImageSharp tests
1 parent bd54606 commit 9764802

1 file changed

Lines changed: 388 additions & 0 deletions

File tree

‎BCnEncTests/ImageSharpTests.cs‎

Lines changed: 388 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,388 @@
1+
using System.IO;
2+
using System.Threading.Tasks;
3+
using BCnEncoder.Decoder;
4+
using BCnEncoder.Encoder;
5+
using BCnEncoder.ImageSharp;
6+
using BCnEncoder.Shared;
7+
using BCnEncoder.Shared.ImageFiles;
8+
using BCnEncTests.Support;
9+
using SixLabors.ImageSharp;
10+
using SixLabors.ImageSharp.PixelFormats;
11+
using Xunit;
12+
13+
namespace BCnEncTests
14+
{
15+
public class ImageSharpEncodingTests
16+
{
17+
private readonly BcEncoder encoder;
18+
private readonly BcDecoder decoder;
19+
private readonly Image<Rgba32> original;
20+
private readonly Image<Rgba32>[] cubemap;
21+
22+
public ImageSharpEncodingTests()
23+
{
24+
encoder = new BcEncoder();
25+
encoder.OutputOptions.Quality = CompressionQuality.Fast;
26+
decoder = new BcDecoder();
27+
original = ImageLoader.LoadTestImageSharp("../../../testImages/test_gradient_1_512.jpg");
28+
cubemap = new[]
29+
{
30+
ImageLoader.LoadTestImageSharp("../../../testImages/cubemap/right.png"),
31+
ImageLoader.LoadTestImageSharp("../../../testImages/cubemap/left.png"),
32+
ImageLoader.LoadTestImageSharp("../../../testImages/cubemap/top.png"),
33+
ImageLoader.LoadTestImageSharp("../../../testImages/cubemap/bottom.png"),
34+
ImageLoader.LoadTestImageSharp("../../../testImages/cubemap/back.png"),
35+
ImageLoader.LoadTestImageSharp("../../../testImages/cubemap/forward.png"),
36+
};
37+
}
38+
39+
[Fact]
40+
public void EncodeToKtx()
41+
{
42+
var ktx = encoder.EncodeToKtx(original);
43+
using var decoded = decoder.DecodeToImageRgba32(ktx);
44+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
45+
}
46+
47+
[Fact]
48+
public void EncodeToDds()
49+
{
50+
var dds = encoder.EncodeToDds(original);
51+
using var decoded = decoder.DecodeToImageRgba32(dds);
52+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
53+
}
54+
55+
[Fact]
56+
public void EncodeToStreamKtx()
57+
{
58+
encoder.OutputOptions.FileFormat = OutputFileFormat.Ktx;
59+
using var ms = new MemoryStream();
60+
encoder.EncodeToStream(original, ms);
61+
ms.Position = 0;
62+
using var decoded = decoder.DecodeToImageRgba32(ms);
63+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
64+
}
65+
66+
[Fact]
67+
public void EncodeToStreamDds()
68+
{
69+
encoder.OutputOptions.FileFormat = OutputFileFormat.Dds;
70+
using var ms = new MemoryStream();
71+
encoder.EncodeToStream(original, ms);
72+
ms.Position = 0;
73+
using var decoded = decoder.DecodeToImageRgba32(ms);
74+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
75+
}
76+
77+
[Fact]
78+
public void EncodeToRawBytes()
79+
{
80+
var rawBytes = encoder.EncodeToRawBytes(original);
81+
using var decoded = decoder.DecodeRawToImageRgba32(rawBytes[0], original.Width, original.Height, CompressionFormat.Bc1);
82+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
83+
}
84+
85+
[Fact]
86+
public void EncodeToRawBytesSingleMip()
87+
{
88+
var mip0 = encoder.EncodeToRawBytes(original, 0, out var mipWidth, out var mipHeight);
89+
Assert.Equal(original.Width, mipWidth);
90+
Assert.Equal(original.Height, mipHeight);
91+
Assert.True(mip0.Length > 0);
92+
}
93+
94+
[Fact]
95+
public void CalculateMipLevelCount()
96+
{
97+
var fromImage = encoder.CalculateNumberOfMipLevels(original);
98+
var fromDims = encoder.CalculateNumberOfMipLevels(original.Width, original.Height);
99+
Assert.Equal(fromDims, fromImage);
100+
}
101+
102+
[Fact]
103+
public void CalculateMipMapSize()
104+
{
105+
encoder.CalculateMipMapSize(original, 0, out var w0, out var h0);
106+
Assert.Equal(original.Width, w0);
107+
Assert.Equal(original.Height, h0);
108+
109+
encoder.CalculateMipMapSize(original, 1, out var w1, out var h1);
110+
Assert.Equal(original.Width / 2, w1);
111+
Assert.Equal(original.Height / 2, h1);
112+
}
113+
114+
[Fact]
115+
public void EncodeCubeMapToKtx()
116+
{
117+
var ktx = encoder.EncodeCubeMapToKtx(cubemap[0], cubemap[1], cubemap[2], cubemap[3], cubemap[4], cubemap[5]);
118+
Assert.Equal(6, ktx.MipMaps[0].Faces.Length);
119+
for (var i = 0; i < 6; i++)
120+
{
121+
var face = ktx.MipMaps[0].Faces[i];
122+
using var decoded = decoder.DecodeRawToImageRgba32(face.Data, (int)face.Width, (int)face.Height, CompressionFormat.Bc1);
123+
TestHelper.AssertImagesEqual(cubemap[i], decoded, encoder.OutputOptions.Quality);
124+
}
125+
}
126+
127+
[Fact]
128+
public void EncodeCubeMapToDds()
129+
{
130+
var dds = encoder.EncodeCubeMapToDds(cubemap[0], cubemap[1], cubemap[2], cubemap[3], cubemap[4], cubemap[5]);
131+
Assert.Equal(6, dds.Faces.Count);
132+
for (var i = 0; i < 6; i++)
133+
{
134+
var face = dds.Faces[i].MipMaps[0];
135+
using var decoded = decoder.DecodeRawToImageRgba32(face.Data, (int)face.Width, (int)face.Height, CompressionFormat.Bc1);
136+
TestHelper.AssertImagesEqual(cubemap[i], decoded, encoder.OutputOptions.Quality);
137+
}
138+
}
139+
140+
[Fact]
141+
public void EncodeCubeMapToStream()
142+
{
143+
encoder.OutputOptions.FileFormat = OutputFileFormat.Ktx;
144+
using var ms = new MemoryStream();
145+
encoder.EncodeCubeMapToStream(cubemap[0], cubemap[1], cubemap[2], cubemap[3], cubemap[4], cubemap[5], ms);
146+
ms.Position = 0;
147+
var ktx = KtxFile.Load(ms);
148+
Assert.Equal(6, ktx.MipMaps[0].Faces.Length);
149+
}
150+
151+
[Fact]
152+
public async Task EncodeToKtxAsync()
153+
{
154+
var ktx = await encoder.EncodeToKtxAsync(original);
155+
using var decoded = decoder.DecodeToImageRgba32(ktx);
156+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
157+
}
158+
159+
[Fact]
160+
public async Task EncodeToDdsAsync()
161+
{
162+
var dds = await encoder.EncodeToDdsAsync(original);
163+
using var decoded = decoder.DecodeToImageRgba32(dds);
164+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
165+
}
166+
167+
[Fact]
168+
public async Task EncodeToStreamAsync()
169+
{
170+
encoder.OutputOptions.FileFormat = OutputFileFormat.Ktx;
171+
using var ms = new MemoryStream();
172+
await encoder.EncodeToStreamAsync(original, ms);
173+
ms.Position = 0;
174+
using var decoded = decoder.DecodeToImageRgba32(ms);
175+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
176+
}
177+
178+
[Fact]
179+
public async Task EncodeToRawBytesAsync()
180+
{
181+
var rawBytes = await encoder.EncodeToRawBytesAsync(original);
182+
using var decoded = decoder.DecodeRawToImageRgba32(rawBytes[0], original.Width, original.Height, CompressionFormat.Bc1);
183+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
184+
}
185+
186+
[Fact]
187+
public async Task EncodeCubeMapToKtxAsync()
188+
{
189+
var ktx = await encoder.EncodeCubeMapToKtxAsync(cubemap[0], cubemap[1], cubemap[2], cubemap[3], cubemap[4], cubemap[5]);
190+
Assert.Equal(6, ktx.MipMaps[0].Faces.Length);
191+
}
192+
193+
[Fact]
194+
public async Task EncodeCubeMapToDdsAsync()
195+
{
196+
var dds = await encoder.EncodeCubeMapToDdsAsync(cubemap[0], cubemap[1], cubemap[2], cubemap[3], cubemap[4], cubemap[5]);
197+
Assert.Equal(6, dds.Faces.Count);
198+
}
199+
200+
[Fact]
201+
public async Task EncodeCubeMapToStreamAsync()
202+
{
203+
encoder.OutputOptions.FileFormat = OutputFileFormat.Ktx;
204+
using var ms = new MemoryStream();
205+
await encoder.EncodeCubeMapToStreamAsync(cubemap[0], cubemap[1], cubemap[2], cubemap[3], cubemap[4], cubemap[5], ms);
206+
ms.Position = 0;
207+
var ktx = KtxFile.Load(ms);
208+
Assert.Equal(6, ktx.MipMaps[0].Faces.Length);
209+
}
210+
}
211+
212+
public class ImageSharpDecodingTests
213+
{
214+
private readonly BcEncoder encoder;
215+
private readonly BcDecoder decoder;
216+
private readonly Image<Rgba32> original;
217+
private readonly KtxFile encodedKtx;
218+
private readonly DdsFile encodedDds;
219+
private readonly byte[] rawEncoded;
220+
221+
public ImageSharpDecodingTests()
222+
{
223+
encoder = new BcEncoder();
224+
encoder.OutputOptions.Quality = CompressionQuality.Fast;
225+
decoder = new BcDecoder();
226+
original = ImageLoader.LoadTestImageSharp("../../../testImages/test_gradient_1_512.jpg");
227+
encodedKtx = encoder.EncodeToKtx(ImageLoader.TestGradient1);
228+
encodedDds = encoder.EncodeToDds(ImageLoader.TestGradient1);
229+
rawEncoded = encoder.EncodeToRawBytes(ImageLoader.TestGradient1)[0];
230+
}
231+
232+
[Fact]
233+
public void DecodeKtxFile()
234+
{
235+
using var decoded = decoder.DecodeToImageRgba32(encodedKtx);
236+
Assert.Equal(original.Width, decoded.Width);
237+
Assert.Equal(original.Height, decoded.Height);
238+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
239+
}
240+
241+
[Fact]
242+
public void DecodeDdsFile()
243+
{
244+
using var decoded = decoder.DecodeToImageRgba32(encodedDds);
245+
Assert.Equal(original.Width, decoded.Width);
246+
Assert.Equal(original.Height, decoded.Height);
247+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
248+
}
249+
250+
[Fact]
251+
public void DecodeStream()
252+
{
253+
using var ms = new MemoryStream();
254+
encodedKtx.Write(ms);
255+
ms.Position = 0;
256+
using var decoded = decoder.DecodeToImageRgba32(ms);
257+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
258+
}
259+
260+
[Fact]
261+
public void DecodeAllMipMapsKtx()
262+
{
263+
encoder.OutputOptions.GenerateMipMaps = true;
264+
var ktxWithMips = encoder.EncodeToKtx(ImageLoader.TestGradient1);
265+
var images = decoder.DecodeAllMipMapsToImageRgba32(ktxWithMips);
266+
267+
Assert.Equal((int)ktxWithMips.header.NumberOfMipmapLevels, images.Length);
268+
Assert.True(images.Length > 1);
269+
TestHelper.AssertImagesEqual(original, images[0], encoder.OutputOptions.Quality);
270+
271+
foreach (var img in images) img.Dispose();
272+
}
273+
274+
[Fact]
275+
public void DecodeAllMipMapsDds()
276+
{
277+
encoder.OutputOptions.GenerateMipMaps = true;
278+
var ddsWithMips = encoder.EncodeToDds(ImageLoader.TestGradient1);
279+
var images = decoder.DecodeAllMipMapsToImageRgba32(ddsWithMips);
280+
281+
Assert.Equal((int)ddsWithMips.header.dwMipMapCount, images.Length);
282+
Assert.True(images.Length > 1);
283+
284+
foreach (var img in images) img.Dispose();
285+
}
286+
287+
[Fact]
288+
public void DecodeAllMipMapsStream()
289+
{
290+
encoder.OutputOptions.GenerateMipMaps = true;
291+
var ktxWithMips = encoder.EncodeToKtx(ImageLoader.TestGradient1);
292+
using var ms = new MemoryStream();
293+
ktxWithMips.Write(ms);
294+
ms.Position = 0;
295+
296+
var images = decoder.DecodeAllMipMapsToImageRgba32(ms);
297+
Assert.Equal((int)ktxWithMips.header.NumberOfMipmapLevels, images.Length);
298+
299+
foreach (var img in images) img.Dispose();
300+
}
301+
302+
[Fact]
303+
public void DecodeRaw()
304+
{
305+
using var decoded = decoder.DecodeRawToImageRgba32(rawEncoded, original.Width, original.Height, CompressionFormat.Bc1);
306+
Assert.Equal(original.Width, decoded.Width);
307+
Assert.Equal(original.Height, decoded.Height);
308+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
309+
}
310+
311+
[Fact]
312+
public void DecodeRawStream()
313+
{
314+
using var ms = new MemoryStream(rawEncoded);
315+
using var decoded = decoder.DecodeRawToImageRgba32(ms, original.Width, original.Height, CompressionFormat.Bc1);
316+
Assert.Equal(original.Width, decoded.Width);
317+
Assert.Equal(original.Height, decoded.Height);
318+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
319+
}
320+
321+
[Fact]
322+
public async Task DecodeKtxFileAsync()
323+
{
324+
using var decoded = await decoder.DecodeToImageRgba32Async(encodedKtx);
325+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
326+
}
327+
328+
[Fact]
329+
public async Task DecodeDdsFileAsync()
330+
{
331+
using var decoded = await decoder.DecodeToImageRgba32Async(encodedDds);
332+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
333+
}
334+
335+
[Fact]
336+
public async Task DecodeStreamAsync()
337+
{
338+
using var ms = new MemoryStream();
339+
encodedKtx.Write(ms);
340+
ms.Position = 0;
341+
using var decoded = await decoder.DecodeToImageRgba32Async(ms);
342+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
343+
}
344+
345+
[Fact]
346+
public async Task DecodeAllMipMapsKtxAsync()
347+
{
348+
encoder.OutputOptions.GenerateMipMaps = true;
349+
var ktxWithMips = encoder.EncodeToKtx(ImageLoader.TestGradient1);
350+
var images = await decoder.DecodeAllMipMapsToImageRgba32Async(ktxWithMips);
351+
352+
Assert.Equal((int)ktxWithMips.header.NumberOfMipmapLevels, images.Length);
353+
Assert.True(images.Length > 1);
354+
355+
foreach (var img in images) img.Dispose();
356+
}
357+
358+
[Fact]
359+
public async Task DecodeAllMipMapsStreamAsync()
360+
{
361+
encoder.OutputOptions.GenerateMipMaps = true;
362+
var ktxWithMips = encoder.EncodeToKtx(ImageLoader.TestGradient1);
363+
using var ms = new MemoryStream();
364+
ktxWithMips.Write(ms);
365+
ms.Position = 0;
366+
367+
var images = await decoder.DecodeAllMipMapsToImageRgba32Async(ms);
368+
Assert.Equal((int)ktxWithMips.header.NumberOfMipmapLevels, images.Length);
369+
370+
foreach (var img in images) img.Dispose();
371+
}
372+
373+
[Fact]
374+
public async Task DecodeRawAsync()
375+
{
376+
using var decoded = await decoder.DecodeRawToImageRgba32Async(rawEncoded, original.Width, original.Height, CompressionFormat.Bc1);
377+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
378+
}
379+
380+
[Fact]
381+
public async Task DecodeRawStreamAsync()
382+
{
383+
using var ms = new MemoryStream(rawEncoded);
384+
using var decoded = await decoder.DecodeRawToImageRgba32Async(ms, original.Width, original.Height, CompressionFormat.Bc1);
385+
TestHelper.AssertImagesEqual(original, decoded, encoder.OutputOptions.Quality);
386+
}
387+
}
388+
}

0 commit comments

Comments
 (0)