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

704 lines
29 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
{
Tests: Move jpg test images into jpg/ subfolder
2023-06-18 22:55:38 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("jpg/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)
{
Tests: Move jpg test images into jpg/ subfolder
2023-06-18 22:55:38 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("jpg/several_scans.jpg"sv)));
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
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)
{
Tests: Move jpg test images into jpg/ subfolder
2023-06-18 22:55:38 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("jpg/rgb_components.jpg"sv)));
Tests: Add a test for JPEGs with RGB components
2023-03-05 03:05:02 +00:00
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)
{
Tests: Move jpg test images into jpg/ subfolder
2023-06-18 22:55:38 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("jpg/spectral_selection.jpg"sv)));
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
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)
{
Tests: Move jpg test images into jpg/ subfolder
2023-06-18 22:55:38 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("jpg/several_scans_odd_number_mcu.jpg"sv)));
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
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)
{
Tests: Move jpg test images into jpg/ subfolder
2023-06-18 22:55:38 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("jpg/successive_approximation.jpg"sv)));
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
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)
{
Tests: Move jpg test images into jpg/ subfolder
2023-06-18 22:55:38 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("jpg/12-bit.jpg"sv)));
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
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)
{
Tests: Move jpg test images into jpg/ subfolder
2023-06-18 22:55:38 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("jpg/12-bit-progressive.jpg"sv)));
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
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)
{
Tests: Move tga test images into tga/ subfolder
2023-06-18 22:56:41 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("tga/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)
{
Tests: Move tga test images into tga/ subfolder
2023-06-18 22:56:41 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("tga/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)
{
Tests: Move tga test images into tga/ subfolder
2023-06-18 22:56:41 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("tga/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)
{
Tests: Move tga test images into tga/ subfolder
2023-06-18 22:56:41 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("tga/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)
{
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/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)
{
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/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));
WebP/Lossless: Set alpha to 0xff if is_alpha_used is false in header simple-vp8l-alpha-used-false.webp is a copy of simple-vp8l.webp, with the byte at offset 0x18 changed from 0x10 to 0x00 -- that is, the bit in the VP8L header that stores `is_alpha_used` is cleared. We would already allocated a BGRx8888 instead of a BGRA8888 bitmap, but keep actual alpha data in the `x` channel. That lead to at least `image` still writing a PNG with an alpha channel. So explicitly set the alpha channel to 0xff when is_alpha_used is false, to make sure all consumers of decoded lossless webp data have behavior consistent with other webp readers. In practice, webp encoders usually don't write files that have `is_alpha_used` set to false and then write actual alpha data to their output. So this is rarely observable. However, for example for lossy+ALPH webp files, the lossless webp used to store the ALPH channel has `is_alpha_used` set to false and all channels but green are 0 (since the lossless green channel stores the alpha channel of a lossy+ALPH webp). So if we dump such a bitmap to a standalone webp file (e.g. with the temporary debugging code in fc3249a1ca8f42e72), then without this commit here, `image` would convert that webp to a fully transparent webp, while other webp software would correctly display the green image with opaque alpha.
2023-06-18 14:47:05 +00:00
EXPECT_EQ(frame.image->get_pixel(0, 0), Gfx::Color(0, 0, 0, 0));
Tests: Add another test for webp lossless decoding
2023-04-06 17:33:43 +00:00
// 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
}
WebP/Lossless: Set alpha to 0xff if is_alpha_used is false in header simple-vp8l-alpha-used-false.webp is a copy of simple-vp8l.webp, with the byte at offset 0x18 changed from 0x10 to 0x00 -- that is, the bit in the VP8L header that stores `is_alpha_used` is cleared. We would already allocated a BGRx8888 instead of a BGRA8888 bitmap, but keep actual alpha data in the `x` channel. That lead to at least `image` still writing a PNG with an alpha channel. So explicitly set the alpha channel to 0xff when is_alpha_used is false, to make sure all consumers of decoded lossless webp data have behavior consistent with other webp readers. In practice, webp encoders usually don't write files that have `is_alpha_used` set to false and then write actual alpha data to their output. So this is rarely observable. However, for example for lossy+ALPH webp files, the lossless webp used to store the ALPH channel has `is_alpha_used` set to false and all channels but green are 0 (since the lossless green channel stores the alpha channel of a lossy+ALPH webp). So if we dump such a bitmap to a standalone webp file (e.g. with the temporary debugging code in fc3249a1ca8f42e72), then without this commit here, `image` would convert that webp to a fully transparent webp, while other webp software would correctly display the green image with opaque alpha.
2023-06-18 14:47:05 +00:00
TEST_CASE(test_webp_simple_lossless_alpha_used_false)
{
// This file is identical to simple-vp8l.webp, but the `is_alpha_used` used bit is false.
// The file still contains alpha data. This tests that the decoder replaces the stored alpha data with 0xff if `is_alpha_used` is false.
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/simple-vp8l-alpha-used-false.webp"sv)));
WebP/Lossless: Set alpha to 0xff if is_alpha_used is false in header simple-vp8l-alpha-used-false.webp is a copy of simple-vp8l.webp, with the byte at offset 0x18 changed from 0x10 to 0x00 -- that is, the bit in the VP8L header that stores `is_alpha_used` is cleared. We would already allocated a BGRx8888 instead of a BGRA8888 bitmap, but keep actual alpha data in the `x` channel. That lead to at least `image` still writing a PNG with an alpha channel. So explicitly set the alpha channel to 0xff when is_alpha_used is false, to make sure all consumers of decoded lossless webp data have behavior consistent with other webp readers. In practice, webp encoders usually don't write files that have `is_alpha_used` set to false and then write actual alpha data to their output. So this is rarely observable. However, for example for lossy+ALPH webp files, the lossless webp used to store the ALPH channel has `is_alpha_used` set to false and all channels but green are 0 (since the lossless green channel stores the alpha channel of a lossy+ALPH webp). So if we dump such a bitmap to a standalone webp file (e.g. with the temporary debugging code in fc3249a1ca8f42e72), then without this commit here, `image` would convert that webp to a fully transparent webp, while other webp software would correctly display the green image with opaque alpha.
2023-06-18 14:47:05 +00:00
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(386, 395));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(386, 395));
EXPECT_EQ(frame.image->get_pixel(0, 0), Gfx::Color(0, 0, 0, 0xff));
}
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
TEST_CASE(test_webp_extended_lossy)
{
WebP: Add test for horizontal ALPH chunk filtering_method
2023-06-08 21:28:59 +00:00
// This extended lossy image has an ALPH chunk for (losslessly compressed) alpha data.
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/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: Add test for horizontal ALPH chunk filtering_method
2023-06-08 21:28:59 +00:00
TEST_CASE(test_webp_extended_lossy_alpha_horizontal_filter)
{
// Also lossy rgb + lossless alpha, but with a horizontal alpha filtering method.
// The image should look like smolkling.webp, but with a horizontal alpha gradient.
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/smolkling-horizontal-alpha.webp"sv)));
WebP: Add test for horizontal ALPH chunk filtering_method
2023-06-08 21:28:59 +00:00
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(264, 264));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(264, 264));
// 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.
// The important component in this test is alpha, and that shouldn't change even by 1 as it's losslessly compressed and doesn't use YUV.
EXPECT_EQ(frame.image->get_pixel(131, 131), Gfx::Color(0x8f, 0x51, 0x2f, 0x4b));
}
WebP: Add test for vertical ALPH chunk filtering_method
2023-06-08 22:28:11 +00:00
TEST_CASE(test_webp_extended_lossy_alpha_vertical_filter)
{
// Also lossy rgb + lossless alpha, but with a vertical alpha filtering method.
// The image should look like smolkling.webp, but with a vertical alpha gradient, and with a fully transparent first column.
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/smolkling-vertical-alpha.webp"sv)));
WebP: Add test for vertical ALPH chunk filtering_method
2023-06-08 22:28:11 +00:00
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(264, 264));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(264, 264));
// 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.
// The important component in this test is alpha, and that shouldn't change even by 1 as it's losslessly compressed and doesn't use YUV.
EXPECT_EQ(frame.image->get_pixel(131, 131), Gfx::Color(0x94, 0x50, 0x32, 0x4c));
}
WebP: Add test for gradient ALPH chunk filtering_method
2023-06-08 21:55:39 +00:00
TEST_CASE(test_webp_extended_lossy_alpha_gradient_filter)
{
// Also lossy rgb + lossless alpha, but with a gradient alpha filtering method.
// The image should look like smolkling.webp, but with a few transparent pixels in the shape of a C on it. Most of the image should not be transparent.
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/smolkling-gradient-alpha.webp"sv)));
WebP: Add test for gradient ALPH chunk filtering_method
2023-06-08 21:55:39 +00:00
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(264, 264));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(264, 264));
// 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.
// The important component in this test is alpha, and that shouldn't change even by 1 as it's losslessly compressed and doesn't use YUV.
// In particular, the center of the image should be fully opaque, not fully transparent.
EXPECT_EQ(frame.image->get_pixel(131, 131), Gfx::Color(0x8c, 0x47, 0x2e, 255));
}
WebP/Lossy: Add test for lossy webp with uncompressed alpha The alpha channel of a lossy webp is always stored separately from the (lossy) RGB data. Alpha is either compressed in a lossless webp that stores just the alpha data, or it's stored completely uncompressed. (But again, even if it's compressed, it's losslessly compressed.) This adds a test for uncompressed alpha, which I hadn't tested before. It seems to work correctly, though :^) I generated the test image by running: ~/Downloads/libwebp-1.3.0-mac-arm64/bin/cwebp \ -alpha_method 0 \ Tests/LibGfx/test-inputs/extended-lossless.webp \ -o Tests/LibGfx/test-inputs/extended-lossy-uncompressed-alpha.webp
2023-05-29 23:19:29 +00:00
TEST_CASE(test_webp_extended_lossy_uncompressed_alpha)
{
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/extended-lossy-uncompressed-alpha.webp"sv)));
WebP/Lossy: Add test for lossy webp with uncompressed alpha The alpha channel of a lossy webp is always stored separately from the (lossy) RGB data. Alpha is either compressed in a lossless webp that stores just the alpha data, or it's stored completely uncompressed. (But again, even if it's compressed, it's losslessly compressed.) This adds a test for uncompressed alpha, which I hadn't tested before. It seems to work correctly, though :^) I generated the test image by running: ~/Downloads/libwebp-1.3.0-mac-arm64/bin/cwebp \ -alpha_method 0 \ Tests/LibGfx/test-inputs/extended-lossless.webp \ -o Tests/LibGfx/test-inputs/extended-lossy-uncompressed-alpha.webp
2023-05-29 23:19:29 +00:00
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(417, 223));
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, 0, 4, 255));
EXPECT_EQ(frame.image->get_pixel(174, 69), Gfx::Color(4, 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));
}
WebP/Lossy: Clamp negative quantization indices to zero The spec doesn't talk about this happening in the text, but `dequant_init()` in 20.4 stores `q` in an int and clamps that to 0 later.
2023-06-01 13:09:24 +00:00
TEST_CASE(test_webp_extended_lossy_negative_quantization_offset)
{
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/smolkling.webp"sv)));
WebP/Lossy: Clamp negative quantization indices to zero The spec doesn't talk about this happening in the text, but `dequant_init()` in 20.4 stores `q` in an int and clamps that to 0 later.
2023-06-01 13:09:24 +00:00
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(264, 264));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(264, 264));
// 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(16, 16), Gfx::Color(0x3c, 0x24, 0x1a, 255));
}
WebP/Lossy: Use correct test image for coefficient skipping I somehow added the wrong image here. 4.webp is the one described by the comment in the test. Now test actually uses the image it claims to use. No behavior change.
2023-05-30 14:21:58 +00:00
TEST_CASE(test_webp_lossy_4)
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
{
// 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.
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/4.webp"sv)));
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
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());
WebP/Lossy: Use correct test image for coefficient skipping I somehow added the wrong image here. 4.webp is the one described by the comment in the test. Now test actually uses the image it claims to use. No behavior change.
2023-05-30 14:21:58 +00:00
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(1024, 772));
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
auto frame = MUST(plugin_decoder->frame(0));
WebP/Lossy: Use correct test image for coefficient skipping I somehow added the wrong image here. 4.webp is the one described by the comment in the test. Now test actually uses the image it claims to use. No behavior change.
2023-05-30 14:21:58 +00:00
EXPECT_EQ(frame.image->size(), Gfx::IntSize(1024, 772));
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
// This image tests macroblocks that have `skip_coefficients` set to true, and it test a boolean entropy decoder edge case.
WebP/Lossy: Use correct test image for coefficient skipping I somehow added the wrong image here. 4.webp is the one described by the comment in the test. Now test actually uses the image it claims to use. No behavior change.
2023-05-30 14:21:58 +00:00
EXPECT_EQ(frame.image->get_pixel(780, 570), Gfx::Color(0x72, 0xc8, 0xf6, 255));
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
}
WebP/Lossy: Add support for images with more than one partition Each secondary partition has an independent BooleanDecoder. Their bitstreams interleave per macroblock row, that is the first macroblock row is read from the first decoder, the second from the second, ..., until it wraps around again. All partitions share a single prediction state though: The second macroblock row (which reads coefficients off the second decoder) is predicted using the result of decoding the frist macroblock row (which reads coefficients off the first decoder). So if I understand things right, in theory the coefficient reading could be parallelized, but prediction can't be. (IDCT can also be parallelized, but that's true with just a single partition too.) I created the test image by running examples/cwebp -low_memory -partitions 3 -o foo.webp \ ~/src/serenity/Tests/LibGfx/test-inputs/4.webp using a cwebp hacked up as described in #19149. Since creating multi-partition lossy webps requires hacking up `cwebp`, they're likely very rare in practice. (But maybe other programs using the libwebp API create them.) Fixes #19149. With this, webp lossy support is complete (*) :^) And with that, webp support is complete: Lossless, lossy, lossy with alpha, animated lossless, animated lossy, animated lossy with alpha all work. (*: Loop filtering isn't implemented yet, which has a minor visual effect on the output. But it's only visible when carefully comparing a webp decoded without loop filtering to the same decoded with it. But it's technically a part of the spec that's still missing. The upsampling of UV in the YUV->RGB code is also low-quality. This produces somewhat visible banding in practice in some images (e.g. in the fire breather's face in 5.webp), so we should probably improve that at some point. Our JPG decoder has the same issue.)
2023-05-30 14:10:14 +00:00
TEST_CASE(test_webp_lossy_4_with_partitions)
{
// Same input file as in the previous test, but re-encoded to use 8 secondary partitions.
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/4-with-8-partitions.webp"sv)));
WebP/Lossy: Add support for images with more than one partition Each secondary partition has an independent BooleanDecoder. Their bitstreams interleave per macroblock row, that is the first macroblock row is read from the first decoder, the second from the second, ..., until it wraps around again. All partitions share a single prediction state though: The second macroblock row (which reads coefficients off the second decoder) is predicted using the result of decoding the frist macroblock row (which reads coefficients off the first decoder). So if I understand things right, in theory the coefficient reading could be parallelized, but prediction can't be. (IDCT can also be parallelized, but that's true with just a single partition too.) I created the test image by running examples/cwebp -low_memory -partitions 3 -o foo.webp \ ~/src/serenity/Tests/LibGfx/test-inputs/4.webp using a cwebp hacked up as described in #19149. Since creating multi-partition lossy webps requires hacking up `cwebp`, they're likely very rare in practice. (But maybe other programs using the libwebp API create them.) Fixes #19149. With this, webp lossy support is complete (*) :^) And with that, webp support is complete: Lossless, lossy, lossy with alpha, animated lossless, animated lossy, animated lossy with alpha all work. (*: Loop filtering isn't implemented yet, which has a minor visual effect on the output. But it's only visible when carefully comparing a webp decoded without loop filtering to the same decoded with it. But it's technically a part of the spec that's still missing. The upsampling of UV in the YUV->RGB code is also low-quality. This produces somewhat visible banding in practice in some images (e.g. in the fire breather's face in 5.webp), so we should probably improve that at some point. Our JPG decoder has the same issue.)
2023-05-30 14:10:14 +00:00
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, 772));
auto frame = MUST(plugin_decoder->frame(0));
EXPECT_EQ(frame.image->size(), Gfx::IntSize(1024, 772));
EXPECT_EQ(frame.image->get_pixel(780, 570), Gfx::Color(0x73, 0xc9, 0xf9, 255));
}
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
TEST_CASE(test_webp_extended_lossless)
{
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/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.
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/Qpalette.webp"sv)));
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(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[] = {
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
{ "webp/catdog-alert-2.webp"sv, Gfx::Color(0x35, 0x12, 0x0a, 0xff), Gfx::Color(0xf3, 0xe6, 0xd8, 0xff) },
{ "webp/catdog-alert-3.webp"sv, Gfx::Color(0x35, 0x12, 0x0a, 0xff), Gfx::Color(0, 0, 0, 0) },
{ "webp/catdog-alert-8.webp"sv, Gfx::Color(0, 0, 0, 255), Gfx::Color(0, 0, 0, 0) },
{ "webp/catdog-alert-13.webp"sv, Gfx::Color(0, 0, 0, 255), Gfx::Color(0, 0, 0, 0) },
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
};
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[] = {
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
"webp/width11-height11-colors2.webp"sv,
"webp/width11-height11-colors3.webp"sv,
"webp/width11-height11-colors15.webp"sv,
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
};
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)
{
Tests: Move webp test images into webp/ subfolder
2023-06-18 22:34:25 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("webp/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