beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 15:40:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Tests/LibGfx/TestImageDecoder.cpp

541 lines
21 KiB
C++
Raw Normal View History

Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
/*
* Copyright (c) 2021, the SerenityOS developers.
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
* Copyright (c) 2021, Brian Gianforcaro <bgianf@serenityos.org>
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
*/
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
#include <AK/DeprecatedString.h>
LibCore+AK: Move MappedFile from AK to LibCore MappedFile is strictly a userspace thing, so it doesn't belong in AK (which is supposed to be user/kernel agnostic.)
2021-11-23 10:32:25 +00:00
#include <LibCore/MappedFile.h>
LibGfx: Move all image loaders and writers to a subdirectory
2023-03-21 18:58:06 +00:00
#include <LibGfx/ImageFormats/BMPLoader.h>
#include <LibGfx/ImageFormats/GIFLoader.h>
#include <LibGfx/ImageFormats/ICOLoader.h>
#include <LibGfx/ImageFormats/ImageDecoder.h>
#include <LibGfx/ImageFormats/JPEGLoader.h>
#include <LibGfx/ImageFormats/PBMLoader.h>
#include <LibGfx/ImageFormats/PGMLoader.h>
#include <LibGfx/ImageFormats/PNGLoader.h>
#include <LibGfx/ImageFormats/PPMLoader.h>
#include <LibGfx/ImageFormats/TGALoader.h>
#include <LibGfx/ImageFormats/WebPLoader.h>
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
#include <LibTest/TestCase.h>
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
#include <stdio.h>
#include <string.h>
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
#ifdef AK_OS_SERENITY
# define TEST_INPUT(x) ("/usr/Tests/LibGfx/test-inputs/" x)
#else
# define TEST_INPUT(x) ("test-inputs/" x)
#endif
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_bmp)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("rgba32-1.bmp"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::BMPImageDecoderPlugin::sniff(file->bytes()));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
auto plugin_decoder = MUST(Gfx::BMPImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_gif)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("download-animation.gif"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::GIFImageDecoderPlugin::sniff(file->bytes()));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
auto plugin_decoder = MUST(Gfx::GIFImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
Tests/LibGfx: Fix test_gif test case We should expect the GIF image to be animated, therefore fix that condition.
2023-01-20 16:41:21 +00:00
EXPECT(plugin_decoder->is_animated());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(1));
Tests/LibGfx: Actually test image decoders in TestImageDecoder We were passing raw Gfx::Bitmap objects into the various image decoders instead of encoded image data. This made all of them fail, but the test expectations were set up in a way that aligned with this outcome. With this patch, we now test the codecs for real. Except ICO, since we don't have an ICO file handy. That's a FIXME.
2021-11-11 10:20:58 +00:00
EXPECT(frame.duration == 400);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
TEST_CASE(test_not_ico)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie.png"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(!Gfx::ICOImageDecoderPlugin::sniff(file->bytes()));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
auto plugin_decoder = MUST(Gfx::ICOImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
EXPECT(plugin_decoder->initialize().is_error());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame(0).is_error());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
TEST_CASE(test_bmp_embedded_in_ico)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("serenity.ico"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::ICOImageDecoderPlugin::sniff(file->bytes()));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
auto plugin_decoder = MUST(Gfx::ICOImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->frame(0));
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
}
Tests: Rename "test_jpg" to "test_jpeg_sof0_one_scan"
2023-02-26 22:02:07 +00:00
TEST_CASE(test_jpeg_sof0_one_scan)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("rgb24.jpg"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::JPEGImageDecoderPlugin::sniff(file->bytes()));
LibGfx: Rename `JPGLoader` to `JPEGLoader` The patch also contains modifications on several classes, functions or files that are related to the `JPGLoader`. Renaming include: - JPGLoader{.h, .cpp} - JPGImageDecoderPlugin - JPGLoadingContext - JPG_DEBUG - decode_jpg - FuzzJPGLoader.cpp - Few string literals or texts
2023-02-18 21:09:16 +00:00
auto plugin_decoder = MUST(Gfx::JPEGImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Add a test for SOF0 images with several scans This type of image isn't common, and you can probably only find one by generating it yourself. It can be done using `cjpeg` with the -scan argument. This image has been generated with the following scan file: 0: 0 63 0 0; 1: 0 63 0 0; 2: 0 63 0 0;
2023-02-26 22:07:14 +00:00
TEST_CASE(test_jpeg_sof0_several_scans)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("several_scans.jpg"sv)));
EXPECT(Gfx::JPEGImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::JPEGImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add a test for SOF0 images with several scans This type of image isn't common, and you can probably only find one by generating it yourself. It can be done using `cjpeg` with the -scan argument. This image has been generated with the following scan file: 0: 0 63 0 0; 1: 0 63 0 0; 2: 0 63 0 0;
2023-02-26 22:07:14 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Replace test image with my own creation
2023-03-04 02:44:22 +00:00
EXPECT_EQ(frame.image->size(), Gfx::IntSize(592, 800));
Tests: Add a test for SOF0 images with several scans This type of image isn't common, and you can probably only find one by generating it yourself. It can be done using `cjpeg` with the -scan argument. This image has been generated with the following scan file: 0: 0 63 0 0; 1: 0 63 0 0; 2: 0 63 0 0;
2023-02-26 22:07:14 +00:00
}
Tests: Add a test for JPEGs with RGB components
2023-03-05 03:05:02 +00:00
TEST_CASE(test_jpeg_rgb_components)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("rgb_components.jpg"sv)));
EXPECT(Gfx::JPEGImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::JPEGImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add a test for JPEGs with RGB components
2023-03-05 03:05:02 +00:00
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(592, 800));
}
Tests: Add a test for SOF2 images with only spectral selection You can generate one by using `cjpeg` with the -scan argument. This image has been generated with the following scan file: 0 1 2: 0 0 0 0; 0: 1 9 0 0; 2: 1 63 0 0 ; 1: 1 63 0 0 ; 0: 10 63 0 0;
2023-02-27 19:32:41 +00:00
TEST_CASE(test_jpeg_sof2_spectral_selection)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("spectral_selection.jpg"sv)));
EXPECT(Gfx::JPEGImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::JPEGImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add a test for SOF2 images with only spectral selection You can generate one by using `cjpeg` with the -scan argument. This image has been generated with the following scan file: 0 1 2: 0 0 0 0; 0: 1 9 0 0; 2: 1 63 0 0 ; 1: 1 63 0 0 ; 0: 10 63 0 0;
2023-02-27 19:32:41 +00:00
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(592, 800));
}
LibGfx/JPEG: More support for scans with a single component Introduced in 2c98eff, support for non-interleaved scans was not working for frames with a number of MCU per line or column that is odd. Indeed, the decoder assumed that they have scans that include a fabricated MCU like scans with multiple components. This patch makes the decoder handle images with a number of MCU per line or column that is odd. To do so, as in the current decoder state we do not know if components are interleaved at allocation time, we skip over falsely-created macroblocks when filling them. As stated in 2c98eff, this is probably not a good solution and a whole refactor will be welcome. It also comes with a test that open a square image with a side of 600px, meaning 75 MCUs.
2023-03-04 04:45:47 +00:00
TEST_CASE(test_jpeg_sof0_several_scans_odd_number_mcu)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("several_scans_odd_number_mcu.jpg"sv)));
EXPECT(Gfx::JPEGImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::JPEGImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
LibGfx/JPEG: More support for scans with a single component Introduced in 2c98eff, support for non-interleaved scans was not working for frames with a number of MCU per line or column that is odd. Indeed, the decoder assumed that they have scans that include a fabricated MCU like scans with multiple components. This patch makes the decoder handle images with a number of MCU per line or column that is odd. To do so, as in the current decoder state we do not know if components are interleaved at allocation time, we skip over falsely-created macroblocks when filling them. As stated in 2c98eff, this is probably not a good solution and a whole refactor will be welcome. It also comes with a test that open a square image with a side of 600px, meaning 75 MCUs.
2023-03-04 04:45:47 +00:00
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(600, 600));
}
Tests: Add a test for SOF2 JPEGs with successive approximations This image was generated using `cjpeg` with the following scan file: 0 1 2: 0 0 0 2; 0: 1 63 0 1; 1: 1 63 0 1; 2: 1 63 0 1; 0 1 2: 0 0 2 1; 0: 1 63 1 0; 1: 1 63 1 0; 2: 1 63 1 0; 0 1 2: 0 0 1 0;
2023-03-18 03:39:30 +00:00
TEST_CASE(test_jpeg_sof2_successive_aproximation)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("successive_approximation.jpg"sv)));
EXPECT(Gfx::JPEGImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::JPEGImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add a test for SOF2 JPEGs with successive approximations This image was generated using `cjpeg` with the following scan file: 0 1 2: 0 0 0 2; 0: 1 63 0 1; 1: 1 63 0 1; 2: 1 63 0 1; 0 1 2: 0 0 2 1; 0: 1 63 1 0; 1: 1 63 1 0; 2: 1 63 1 0; 0 1 2: 0 0 1 0;
2023-03-18 03:39:30 +00:00
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(600, 800));
}
Tests: Add tests for 12 bits JPEGs In this commit, two tests are added, one with a `SOF1` image, the other with a `SOF2`.
2023-05-07 20:35:54 +00:00
TEST_CASE(test_jpeg_sof1_12bits)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("12-bit.jpg"sv)));
EXPECT(Gfx::JPEGImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::JPEGImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add tests for 12 bits JPEGs In this commit, two tests are added, one with a `SOF1` image, the other with a `SOF2`.
2023-05-07 20:35:54 +00:00
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(320, 240));
}
TEST_CASE(test_jpeg_sof2_12bits)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("12-bit-progressive.jpg"sv)));
EXPECT(Gfx::JPEGImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::JPEGImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add tests for 12 bits JPEGs In this commit, two tests are added, one with a `SOF1` image, the other with a `SOF2`.
2023-05-07 20:35:54 +00:00
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(320, 240));
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_pbm)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-raw.pbm"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::PBMImageDecoderPlugin::sniff(file->bytes()));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
auto plugin_decoder = MUST(Gfx::PBMImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_pgm)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-raw.pgm"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::PGMImageDecoderPlugin::sniff(file->bytes()));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
auto plugin_decoder = MUST(Gfx::PGMImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_png)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie.png"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::PNGImageDecoderPlugin::sniff(file->bytes()));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
auto plugin_decoder = MUST(Gfx::PNGImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_ppm)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-raw.ppm"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::PPMImageDecoderPlugin::sniff(file->bytes()));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
auto plugin_decoder = MUST(Gfx::PPMImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
TEST_CASE(test_targa_bottom_left)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-bottom-left-uncompressed.tga"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::TGAImageDecoderPlugin::validate_before_create(file->bytes())));
auto plugin_decoder = MUST(Gfx::TGAImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
EXPECT(frame.duration == 0);
}
TEST_CASE(test_targa_top_left)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-top-left-uncompressed.tga"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::TGAImageDecoderPlugin::validate_before_create(file->bytes())));
auto plugin_decoder = MUST(Gfx::TGAImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
EXPECT(frame.duration == 0);
}
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
TEST_CASE(test_targa_bottom_left_compressed)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-bottom-left-compressed.tga"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::TGAImageDecoderPlugin::validate_before_create(file->bytes())));
auto plugin_decoder = MUST(Gfx::TGAImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
EXPECT(frame.duration == 0);
}
TEST_CASE(test_targa_top_left_compressed)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-top-left-compressed.tga"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::TGAImageDecoderPlugin::validate_before_create(file->bytes())));
auto plugin_decoder = MUST(Gfx::TGAImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
EXPECT(frame.duration == 0);
}
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
TEST_CASE(test_webp_simple_lossy)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("simple-vp8.webp"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::WebPImageDecoderPlugin::sniff(file->bytes()));
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(240, 240));
Tests/LibGfx: Add some test coverage for animated webp decoding Also add two FIXME comments for lossy decoding.
2023-05-06 20:28:26 +00:00
WebP/Lossy: Add some basic tests
2023-05-29 17:01:45 +00:00
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(240, 240));
// While VP8 YUV contents are defined bit-exact, the YUV->RGB conversion isn't.
// So pixels changing by 1 or so below is fine if you change code.
EXPECT_EQ(frame.image->get_pixel(120, 232), Gfx::Color(0xf2, 0xef, 0xf0, 255));
EXPECT_EQ(frame.image->get_pixel(198, 202), Gfx::Color(0x7b, 0xaa, 0xd5, 255));
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
}
TEST_CASE(test_webp_simple_lossless)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("simple-vp8l.webp"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::WebPImageDecoderPlugin::sniff(file->bytes()));
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(386, 395));
Tests: Add another test for webp lossless decoding
2023-04-06 17:33:43 +00:00
// Ironically, simple-vp8l.webp is a much more complex file than extended-lossless.webp tested below.
// extended-lossless.webp tests the decoding basics.
// This here tests the predictor, color, and subtract green transforms,
// as well as meta prefix images, one-element canonical code handling,
// and handling of canonical codes with more than 288 elements.
// This image uses all 13 predictor modes of the predictor transform.
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(386, 395));
// This pixel tests all predictor modes except 5, 7, 8, 9, and 13.
EXPECT_EQ(frame.image->get_pixel(289, 332), Gfx::Color(0xf2, 0xee, 0xd3, 255));
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
}
TEST_CASE(test_webp_extended_lossy)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("extended-lossy.webp"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::WebPImageDecoderPlugin::sniff(file->bytes()));
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(417, 223));
Tests/LibGfx: Add some test coverage for animated webp decoding Also add two FIXME comments for lossy decoding.
2023-05-06 20:28:26 +00:00
WebP/Lossy: Add some basic tests
2023-05-29 17:01:45 +00:00
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(417, 223));
// While VP8 YUV contents are defined bit-exact, the YUV->RGB conversion isn't.
// So pixels changing by 1 or so below is fine if you change code.
EXPECT_EQ(frame.image->get_pixel(89, 72), Gfx::Color(255, 1, 0, 255));
EXPECT_EQ(frame.image->get_pixel(174, 69), Gfx::Color(0, 255, 0, 255));
EXPECT_EQ(frame.image->get_pixel(245, 84), Gfx::Color(0, 0, 255, 255));
EXPECT_EQ(frame.image->get_pixel(352, 125), Gfx::Color(0, 0, 0, 128));
EXPECT_EQ(frame.image->get_pixel(355, 106), Gfx::Color(0, 0, 0, 0));
// Check same basic pixels as in test_webp_extended_lossless too.
// (The top-left pixel in the lossy version is fully transparent white, compared to fully transparent black in the lossless version).
EXPECT_EQ(frame.image->get_pixel(0, 0), Gfx::Color(255, 255, 255, 0));
EXPECT_EQ(frame.image->get_pixel(43, 75), Gfx::Color(255, 0, 2, 255));
EXPECT_EQ(frame.image->get_pixel(141, 75), Gfx::Color(0, 255, 3, 255));
EXPECT_EQ(frame.image->get_pixel(235, 75), Gfx::Color(0, 0, 255, 255));
EXPECT_EQ(frame.image->get_pixel(341, 75), Gfx::Color(0, 0, 0, 128));
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
}
WebP/Lossy: Add an additional test case This image covers two things that aren't covered by the existing tests, and I found it useful for testing locally. The image's license allows redistributing it, so add it as a test case.
2023-05-29 19:23:33 +00:00
TEST_CASE(test_webp_lossy_5)
{
// This is https://commons.wikimedia.org/wiki/File:Fr%C3%BChling_bl%C3%BChender_Kirschenbaum.jpg,
// under the Creative Commons Attribution-Share Alike 3.0 Unported license. The image was re-encoded
// as webp at https://developers.google.com/speed/webp/gallery1 and the webp version is from there.
// No other changes have been made.
auto file = MUST(Core::MappedFile::map(TEST_INPUT("5.webp"sv)));
EXPECT(Gfx::WebPImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
MUST(plugin_decoder->initialize());
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(1024, 752));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(1024, 752));
// This image tests macroblocks that have `skip_coefficients` set to true, and it test a boolean entropy decoder edge case.
EXPECT_EQ(frame.image->get_pixel(923, 576), Gfx::Color(0xab, 0x40, 0x14, 255));
}
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
TEST_CASE(test_webp_extended_lossless)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("extended-lossless.webp"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::WebPImageDecoderPlugin::sniff(file->bytes()));
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(417, 223));
Tests: Add test for webp lossless decoding
2023-04-03 18:54:05 +00:00
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(417, 223));
// Check some basic pixels.
EXPECT_EQ(frame.image->get_pixel(0, 0), Gfx::Color(0, 0, 0, 0));
EXPECT_EQ(frame.image->get_pixel(43, 75), Gfx::Color(255, 0, 0, 255));
EXPECT_EQ(frame.image->get_pixel(141, 75), Gfx::Color(0, 255, 0, 255));
EXPECT_EQ(frame.image->get_pixel(235, 75), Gfx::Color(0, 0, 255, 255));
EXPECT_EQ(frame.image->get_pixel(341, 75), Gfx::Color(0, 0, 0, 128));
// Check pixels using the color cache.
EXPECT_EQ(frame.image->get_pixel(94, 73), Gfx::Color(255, 0, 0, 255));
EXPECT_EQ(frame.image->get_pixel(176, 115), Gfx::Color(0, 255, 0, 255));
EXPECT_EQ(frame.image->get_pixel(290, 89), Gfx::Color(0, 0, 255, 255));
EXPECT_EQ(frame.image->get_pixel(359, 73), Gfx::Color(0, 0, 0, 128));
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
}
Tests: Add test for lossless webp file using a color indexing tranform The image is https://quakewiki.org/wiki/File:Qpalette.png in lossless webp format with a color indexing transform. I've created Qpalette.webp by running examples/cwebp -z 0 ~/src/serenity/tmp.ppm -o Qpalette.webp built at libwebp webmproject/libwebp@0825faa4c10d622f2 (without png support, so I first ran Build/lagom/image ~/Downloads/Qpalette.png -o tmp.ppm to convert it from png to a format my cwebp binary could read). This file also happens to explicitly set max_symbol, so it serves as a test for that code path as well.
2023-04-07 19:21:57 +00:00
TEST_CASE(test_webp_simple_lossless_color_index_transform)
{
// In addition to testing the index transform, this file also tests handling of explicity setting max_symbol.
auto file = MUST(Core::MappedFile::map(TEST_INPUT("Qpalette.webp"sv)));
EXPECT(Gfx::WebPImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add test for lossless webp file using a color indexing tranform The image is https://quakewiki.org/wiki/File:Qpalette.png in lossless webp format with a color indexing transform. I've created Qpalette.webp by running examples/cwebp -z 0 ~/src/serenity/tmp.ppm -o Qpalette.webp built at libwebp webmproject/libwebp@0825faa4c10d622f2 (without png support, so I first ran Build/lagom/image ~/Downloads/Qpalette.png -o tmp.ppm to convert it from png to a format my cwebp binary could read). This file also happens to explicitly set max_symbol, so it serves as a test for that code path as well.
2023-04-07 19:21:57 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(256, 256));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(256, 256));
EXPECT_EQ(frame.image->get_pixel(100, 100), Gfx::Color(0x73, 0x37, 0x23, 0xff));
}
Tests: Add webp lossless test with color index and < 16 colors For the test files, I opened Base/res/icons/catdog/alert.png in Adobe Photoshop 2023, used Image->Mode->Index Color...-> Palette: Local (Perceptive) to reduce the number of colors to 13, 8, and 3 with transparency, and 2 without transparency, then converted it back to Image->Mode->RGB Color (else it can't be saved as webp), then File->Save a Copy... to save a WebP (mode lossless) for every palette size.
2023-04-07 22:40:28 +00:00
TEST_CASE(test_webp_simple_lossless_color_index_transform_pixel_bundling)
{
struct TestCase {
StringView file_name;
Gfx::Color line_color;
Gfx::Color background_color;
};
// The number after the dash is the number of colors in each file's color index bitmap.
// catdog-alert-2 tests the 1-bit-per-pixel case,
// catdog-alert-3 tests the 2-bit-per-pixel case,
// catdog-alert-8 and catdog-alert-13 both test the 4-bits-per-pixel case.
TestCase test_cases[] = {
{ "catdog-alert-2.webp"sv, Gfx::Color(0x35, 0x12, 0x0a, 0xff), Gfx::Color(0xf3, 0xe6, 0xd8, 0xff) },
{ "catdog-alert-3.webp"sv, Gfx::Color(0x35, 0x12, 0x0a, 0xff), Gfx::Color(0, 0, 0, 0) },
{ "catdog-alert-8.webp"sv, Gfx::Color(0, 0, 0, 255), Gfx::Color(0, 0, 0, 0) },
{ "catdog-alert-13.webp"sv, Gfx::Color(0, 0, 0, 255), Gfx::Color(0, 0, 0, 0) },
};
for (auto test_case : test_cases) {
auto file = MUST(Core::MappedFile::map(MUST(String::formatted("{}{}", TEST_INPUT(""), test_case.file_name))));
EXPECT(Gfx::WebPImageDecoderPlugin::sniff(file->bytes()));
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add webp lossless test with color index and < 16 colors For the test files, I opened Base/res/icons/catdog/alert.png in Adobe Photoshop 2023, used Image->Mode->Index Color...-> Palette: Local (Perceptive) to reduce the number of colors to 13, 8, and 3 with transparency, and 2 without transparency, then converted it back to Image->Mode->RGB Color (else it can't be saved as webp), then File->Save a Copy... to save a WebP (mode lossless) for every palette size.
2023-04-07 22:40:28 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(32, 32));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(32, 32));
EXPECT_EQ(frame.image->get_pixel(4, 0), test_case.background_color);
EXPECT_EQ(frame.image->get_pixel(5, 0), test_case.line_color);
EXPECT_EQ(frame.image->get_pixel(9, 5), test_case.background_color);
EXPECT_EQ(frame.image->get_pixel(10, 5), test_case.line_color);
EXPECT_EQ(frame.image->get_pixel(11, 5), test_case.background_color);
}
}
LibGfx: Correctly decode webp lossless with small palette and odd width WebP lossless files that use a color indexing transform with <= 16 colors use pixel bundling to pack 2, 4, or 8 pixels into a single pixel. If the image's width doesn't happen to be an exact multiple of the bundling factor, we need to: 1. Use ceil_div() instead of just dividing the width by the bundling factor 2. Remember the original width and use it instead of computing reduced width times bundling factor This does these changes, and adds a simple test for it -- it at least checks that the decoded images have the right size. (I created these images myself in Photoshop, and used the same technique as for Tests/LibGfx/test-inputs/catdog-alert-*.webp to create images with a certain number of colors.)
2023-04-08 21:50:54 +00:00
TEST_CASE(test_webp_simple_lossless_color_index_transform_pixel_bundling_odd_width)
{
StringView file_names[] = {
"width11-height11-colors2.webp"sv,
"width11-height11-colors3.webp"sv,
"width11-height11-colors15.webp"sv,
};
for (auto file_name : file_names) {
auto file = MUST(Core::MappedFile::map(MUST(String::formatted("{}{}", TEST_INPUT(""), file_name))));
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
LibGfx: Correctly decode webp lossless with small palette and odd width WebP lossless files that use a color indexing transform with <= 16 colors use pixel bundling to pack 2, 4, or 8 pixels into a single pixel. If the image's width doesn't happen to be an exact multiple of the bundling factor, we need to: 1. Use ceil_div() instead of just dividing the width by the bundling factor 2. Remember the original width and use it instead of computing reduced width times bundling factor This does these changes, and adds a simple test for it -- it at least checks that the decoded images have the right size. (I created these images myself in Photoshop, and used the same technique as for Tests/LibGfx/test-inputs/catdog-alert-*.webp to create images with a certain number of colors.)
2023-04-08 21:50:54 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(11, 11));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(11, 11));
}
}
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
TEST_CASE(test_webp_extended_lossless_animated)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("extended-lossless-animated.webp"sv)));
LibGfx: Return bool not ErrorOr<bool> from ImageDecoderPlugin::sniff() Nobody made use of the ErrorOr return value and it just added more chance of confusion, since it was not clear if failing to sniff an image should return an error or false. The answer was false, if you returned Error you'd crash the ImageDecoder.
2023-02-26 18:02:50 +00:00
EXPECT(Gfx::WebPImageDecoderPlugin::sniff(file->bytes()));
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
LibGfx+Fuzz: Convert ImageDecoder::initialize to ErrorOr This prevents callers from accidentally discarding the result of initialize(), which was the root cause of this OSS Fuzz bug: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=55896&q=label%3AProj-serenity&sort=summary
2023-05-07 17:27:07 +00:00
MUST(plugin_decoder->initialize());
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
LibGfx: Implement is_animated() and frame_count() for webp plugin
2023-02-26 03:15:34 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 8u);
EXPECT(plugin_decoder->is_animated());
LibGfx: Implement WebPImageDecoderPlugin::loop_count() Turns out extended-lossless-animated.webp did have a loop count of 0. So I opened it in Hex Fiend and changed the byte at position 42 (which is the first byte of the little-endian u16 storing the loop count) to 0x2A, so that the test can compare the loop count to something not 0.
2023-02-26 14:13:27 +00:00
EXPECT_EQ(plugin_decoder->loop_count(), 42u);
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(990, 1050));
Tests/LibGfx: Add some test coverage for animated webp decoding Also add two FIXME comments for lossy decoding.
2023-05-06 20:28:26 +00:00
for (size_t frame_index = 0; frame_index < plugin_decoder->frame_count(); ++frame_index) {
auto frame = MUST(plugin_decoder->frame(frame_index));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(990, 1050));
// This pixel happens to be the same color in all frames.
EXPECT_EQ(frame.image->get_pixel(500, 700), Gfx::Color::Yellow);
// This one isn't the same in all frames.
EXPECT_EQ(frame.image->get_pixel(500, 0), (frame_index == 2 || frame_index == 6) ? Gfx::Color::Black : Gfx::Color(255, 255, 255, 0));
}
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
}
Reference in a new issue Copy permalink