blob: 4aa2ead163675bace0900246bff02222e28fda84 [file] [log] [blame]
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "tests/Test.h"
#include "include/core/SkTypes.h"
#include "include/private/SkFixed.h"
#include "src/core/SkBitmapProcState.h"
#include "src/opts/SkBitmapProcState_opts.h"
#include <cstddef>
#include <cstdint>
#include <string>
int highBits(uint32_t rv) {
return (rv >> 18) & ((1 << 14) - 1);
}
int middleBits(uint32_t rv) {
return (rv >> 14) & ((1 << 4) - 1);
}
int lowBits(uint32_t rv) {
return rv & ((1 << 14) - 1);
}
DEF_TEST(MatrixProcs_pack_clamp, r) {
struct TestCase {
std::string name;
SkFixed input;
unsigned max;
uint32_t expectedOutput;
};
// The input values are somewhat arbitrary, inspired by real-world values
// with some edge cases added as well.
TestCase tests[] = {
// Negative values keep the fractional part out of convenience, but it is effectively
// ignored later.
{"-2.100 => {0x00, 0xe, 0x00}", SkFloatToFixed(-2.100f), 63, 0x38000},
{"-1.900 => {0x00, 0x1, 0x00}", SkFloatToFixed(-1.900f), 63, 0x04000},
{"-0.500 => {0x00, 0x8, 0x00}", SkFloatToFixed(-0.500f), 63, 0x20000},
{"0.0000 => {0x00, 0x0, 0x01}", SkFloatToFixed(0.0000f), 63, 0x000001},
{"0.0416 => {0x00, 0x0, 0x01}", SkFloatToFixed(0.0416f), 63, 0x000001},
{"1.8583 => {0x01, 0xd, 0x02}", SkFloatToFixed(1.8583f), 63, 0x074002},
{"3.6749 => {0x03, 0xa, 0x04}", SkFloatToFixed(3.6749f), 63, 0x0e8004},
{"5.4916 => {0x05, 0x7, 0x06}", SkFloatToFixed(5.4916f), 63, 0x15c006},
{"7.3083 => {0x07, 0x4, 0x08}", SkFloatToFixed(7.3083f), 63, 0x1d0008},
{"9.0000 => {0x09, 0x0, 0x0a}", SkFloatToFixed(9.0000f), 63, 0x24000a},
{"50.000 => {0x32, 0x0, 0x33}", SkFloatToFixed(50.000f), 63, 0xc80033},
{"50.875 => {0x32, 0xe, 0x33}", SkFloatToFixed(50.875f), 63, 0xcb8033},
{"62.123 => {0x3e, 0x1, 0x3f}", SkFloatToFixed(62.123f), 63, 0xf8403f},
{"62.999 => {0x3e, 0xf, 0x3f}", SkFloatToFixed(62.999f), 63, 0xfbc03f},
{"63.000 => {0x3f, 0x0, 0x3f}", SkFloatToFixed(63.000f), 63, 0xfc003f},
// Similarly, overflow keeps the fractional part.
{"64.500 => {0x3f, 0x8, 0x3f}", SkFloatToFixed(64.500f), 63, 0xfe003f},
{"127.20 => {0x3f, 0x3, 0x3f}", SkFloatToFixed(127.20f), 63, 0xfcc03f},
// Maximum has changed from 63 to 256
{"64.510 => {0x40, 0x8, 0x41}", SkFloatToFixed(64.510f), 256, 0x1020041},
{"127.21 => {0x7f, 0x3, 0x80}", SkFloatToFixed(127.21f), 256, 0x1fcc080},
{"256.77 => {0x100, 0xc, 0x100}", SkFloatToFixed(256.77f), 256, 0x4030100},
{"10000. => {0x100, 0x0, 0x100}", SkFloatToFixed(10000.f), 256, 0x4000100},
};
constexpr size_t NUM_TESTS = sizeof(tests) / sizeof(TestCase);
for (size_t i = 0; i < NUM_TESTS; i++) {
TestCase tc = tests[i];
uint32_t rv = sktests::pack_clamp(tc.input, tc.max);
uint32_t exp = tc.expectedOutput;
REPORTER_ASSERT(r, rv == tc.expectedOutput,
"%s | %x != %x | {%x, %x, %x} != {%x, %x, %x}\n",
tc.name.c_str(), rv, exp,
highBits(rv), middleBits(rv), lowBits(rv),
highBits(exp), middleBits(exp), lowBits(exp));
}
}
DEF_TEST(MatrixProcs_pack_clamp_out_of_range, r) {
// See https://crbug.com/1357122
struct TestCase {
std::string name;
SkFixed input;
unsigned max;
uint32_t expectedOutput;
};
// None of these should crash or cause UBSAN errors, although if they were used in drawing,
// they might be incorrect due to packing 16 bits of SkFixed into 14 bits of space.
static constexpr unsigned MAX_PACKED_VALUE = (1 << 14) - 1;
TestCase tests[] = {
{"16000.42=>{0xff, 6, 0xff}", SkFloatToFixed(16000.42f), 255, 0x3fd80ff},
{"17000.42=>{0xff, 6, 0xff}", SkFloatToFixed(17000.42f), 255, 0x3fd80ff},
{"18000.42=>{0xff, 6, 0xff}", SkFloatToFixed(18000.42f), 255, 0x3fd80ff},
{"16000.42=>{0x3e80, 6, 0x3e81}", SkFloatToFixed(16000.42f), MAX_PACKED_VALUE, 0xfa01be81},
{"16382.00=>{0x3ffe, 0, 0x3fff}", SkFloatToFixed(16382.00f), MAX_PACKED_VALUE, 0xfff83fff},
{"16382.51=>{0x3ffe, 8, 0x3fff}}", SkFloatToFixed(16382.51f), MAX_PACKED_VALUE, 0xfffa3fff},
{"17000.42=>{0x3fff, 6, 0x3fff}", SkFloatToFixed(17000.42f), MAX_PACKED_VALUE, 0xfffdbfff},
{"18000.42=>{0x3fff, 6, 0x3fff}", SkFloatToFixed(18000.42f), MAX_PACKED_VALUE, 0xfffdbfff},
// Adding 1 to this would overflow and cause an UBSAN issue, if it were not suppressed.
// We suppress the warning and it wraps around.
{"32767.90=>{0x3fff, e, 0x0}", SkFloatToFixed(32767.90f), MAX_PACKED_VALUE, 0xffff8000},
};
constexpr size_t NUM_TESTS = sizeof(tests) / sizeof(TestCase);
for (size_t i = 0; i < NUM_TESTS; i++) {
TestCase tc = tests[i];
uint32_t rv = sktests::pack_clamp(tc.input, tc.max);
uint32_t exp = tc.expectedOutput;
REPORTER_ASSERT(r, rv == tc.expectedOutput,
"%s | %x != %x | {%x, %x, %x} != {%x, %x, %x}\n",
tc.name.c_str(), rv, exp,
highBits(rv), middleBits(rv), lowBits(rv),
highBits(exp), middleBits(exp), lowBits(exp));
}
}
DEF_TEST(MatrixProcs_pack_repeat, r) {
struct TestCase {
std::string name;
SkFixed input;
unsigned max;
uint32_t expectedOutput;
size_t width;
};
TestCase tests[] = {
// negative values wrap back around
{"-0.300 => {0x2c, 0xc, 0x2d}", SkFloatToFixed(-0.300f), 63, 0xb3002d, 63},
{"-0.200 => {0x33, 0x3, 0x34}", SkFloatToFixed(-0.200f), 63, 0xccc034, 63},
{"-0.100 => {0x39, 0x9, 0x3a}", SkFloatToFixed(-0.100f), 63, 0xe6403a, 63},
// The domain of the function is primarily [0.0, 1.0)
{"0.0000 => {0x00, 0x0, 0x01}", SkFloatToFixed(0.0000f), 63, 0x000001, 63},
{"0.1000 => {0x06, 0x6, 0x07}", SkFloatToFixed(0.1000f), 63, 0x198007, 63},
{"0.1234 => {0x07, 0xe, 0x08}", SkFloatToFixed(0.1234f), 63, 0x1f8008, 63},
{"0.2000 => {0x0c, 0xc, 0x0d}", SkFloatToFixed(0.2000f), 63, 0x33000d, 63},
{"0.3000 => {0x13, 0x3, 0x14}", SkFloatToFixed(0.3000f), 63, 0x4cc014, 63},
{"0.4000 => {0x19, 0x9, 0x1a}", SkFloatToFixed(0.4000f), 63, 0x66401a, 63},
{"0.5000 => {0x20, 0x0, 0x21}", SkFloatToFixed(0.5000f), 63, 0x800021, 63},
{"0.5678 => {0x24, 0x5, 0x25}", SkFloatToFixed(0.5678f), 63, 0x914025, 63},
{"0.6000 => {0x26, 0x6, 0x27}", SkFloatToFixed(0.6000f), 63, 0x998027, 63},
{"0.7000 => {0x2c, 0xc, 0x2d}", SkFloatToFixed(0.7000f), 63, 0xb3002d, 63},
{"0.8000 => {0x33, 0x3, 0x34}", SkFloatToFixed(0.8000f), 63, 0xccc034, 63},
{"0.9000 => {0x39, 0x9, 0x3a}", SkFloatToFixed(0.9000f), 63, 0xe6403a, 63},
{"0.9500 => {0x3c, 0xc, 0x3d}", SkFloatToFixed(0.9500f), 63, 0xf3003d, 63},
{"0.9990 => {0x3f, 0xe, 0x00}", SkFloatToFixed(0.9990f), 63, 0xff8000, 63},
// As we go past 1.0, we wrap around, conceptually similar to modular arithmetic.
{"1.0000 => {0x00, 0x0, 0x01}", SkFloatToFixed(1.0000f), 63, 0x000001, 63},
{"1.1000 => {0x06, 0x6, 0x07}", SkFloatToFixed(1.1000f), 63, 0x198007, 63},
{"1.1234 => {0x07, 0xe, 0x08}", SkFloatToFixed(1.1234f), 63, 0x1f8008, 63},
{"1.9500 => {0x3c, 0xc, 0x3d}", SkFloatToFixed(1.9500f), 63, 0xf3003d, 63},
// Maximum has changed from 63 to 256
{"0.4567 => {0x75, 0x5, 0x76}", SkFloatToFixed(0.4567f), 256, 0x1d54076, 256},
{"1.0000 => {0x00, 0x0, 0x01}", SkFloatToFixed(1.0000f), 256, 0x0000001, 256},
{"1.2345 => {0x3c, 0x4, 0x3d}", SkFloatToFixed(1.2345f), 256, 0x0f1003d, 256},
// width does not have to match the maximum value (e.g. rescaling)
{"0.1111 [64,128] => {0x07, 0x3, 0x07}", SkFloatToFixed(0.1111f), 64, 0x1cc007, 128},
{"0.1111 [64,256] => {0x07, 0x3, 0x07}", SkFloatToFixed(0.1111f), 64, 0x1cc007, 256},
{"0.1111 [64,512] => {0x07, 0x3, 0x07}", SkFloatToFixed(0.1111f), 64, 0x1cc007, 512},
{"0.1111 [64, 32] => {0x07, 0x3, 0x09}", SkFloatToFixed(0.1111f), 64, 0x1cc009, 32},
{"0.1111 [64, 8] => {0x07, 0x3, 0x0f}", SkFloatToFixed(0.1111f), 64, 0x1cc00f, 8},
};
constexpr size_t NUM_TESTS = sizeof(tests) / sizeof(TestCase);
for (size_t i = 0; i < NUM_TESTS; i++) {
TestCase tc = tests[i];
uint32_t rv = sktests::pack_repeat(tc.input, tc.max, tc.width);
uint32_t exp = tc.expectedOutput;
REPORTER_ASSERT(r, rv == tc.expectedOutput,
"%s | %x != %x | {%x, %x, %x} != {%x, %x, %x}\n",
tc.name.c_str(), rv, exp,
highBits(rv), middleBits(rv), lowBits(rv),
highBits(exp), middleBits(exp), lowBits(exp));
}
}
DEF_TEST(MatrixProcs_pack_mirror, r) {
struct TestCase {
std::string name;
SkFixed input;
unsigned max;
uint32_t expectedOutput;
size_t width;
};
TestCase tests[] = {
// negative values are treated similarly to absolute values, except
// the first integer is bigger than the last integer.
{"-0.300 => {0x13, 0xc, 0x12}", SkFloatToFixed(-0.300f), 63, 0x4f0012, 63},
{"-0.200 => {0x0c, 0x3, 0x0b}", SkFloatToFixed(-0.200f), 63, 0x30c00b, 63},
{"-0.100 => {0x06, 0x9, 0x05}", SkFloatToFixed(-0.100f), 63, 0x1a4005, 63},
// The domain of the function is primarily [0.0, 1.0)
{"0.0000 => {0x00, 0x0, 0x01}", SkFloatToFixed(0.0000f), 63, 0x000001, 63},
{"0.1000 => {0x06, 0x6, 0x07}", SkFloatToFixed(0.1000f), 63, 0x198007, 63},
{"0.1234 => {0x07, 0xe, 0x08}", SkFloatToFixed(0.1234f), 63, 0x1f8008, 63},
{"0.2000 => {0x0c, 0xc, 0x0d}", SkFloatToFixed(0.2000f), 63, 0x33000d, 63},
{"0.3000 => {0x13, 0x3, 0x14}", SkFloatToFixed(0.3000f), 63, 0x4cc014, 63},
{"0.4000 => {0x19, 0x9, 0x1a}", SkFloatToFixed(0.4000f), 63, 0x66401a, 63},
{"0.5000 => {0x20, 0x0, 0x21}", SkFloatToFixed(0.5000f), 63, 0x800021, 63},
{"0.5678 => {0x24, 0x5, 0x25}", SkFloatToFixed(0.5678f), 63, 0x914025, 63},
{"0.6000 => {0x26, 0x6, 0x27}", SkFloatToFixed(0.6000f), 63, 0x998027, 63},
{"0.7000 => {0x2c, 0xc, 0x2d}", SkFloatToFixed(0.7000f), 63, 0xb3002d, 63},
{"0.8000 => {0x33, 0x3, 0x34}", SkFloatToFixed(0.8000f), 63, 0xccc034, 63},
{"0.9000 => {0x39, 0x9, 0x3a}", SkFloatToFixed(0.9000f), 63, 0xe6403a, 63},
{"0.9500 => {0x3c, 0xc, 0x3d}", SkFloatToFixed(0.9500f), 63, 0xf3003d, 63},
{"0.9990 => {0x3f, 0xe, 0x3f}", SkFloatToFixed(0.9990f), 63, 0xff803f, 63},
// As we go past 1.0, we bounce back, as off a wall or reflecting off a mirror.
{"1.0000 => {0x3f, 0x0, 0x3e}", SkFloatToFixed(1.0000f), 63, 0xfc003e, 63},
{"1.1000 => {0x39, 0x6, 0x38}", SkFloatToFixed(1.1000f), 63, 0xe58038, 63},
{"1.1234 => {0x38, 0xe, 0x37}", SkFloatToFixed(1.1234f), 63, 0xe38037, 63},
{"1.9500 => {0x03, 0xc, 0x02}", SkFloatToFixed(1.9500f), 63, 0xf0002, 63},
// Maximum has changed from 63 to 256
{"0.4567 => {0x75, 0x5, 0x76}", SkFloatToFixed(0.4567f), 256, 0x1d54076, 256},
{"1.0000 => {0x100,0x0, 0xff}", SkFloatToFixed(1.0000f), 256, 0x40000ff, 256},
{"1.2345 => {0xc4, 0x4, 0xc3}", SkFloatToFixed(1.2345f), 256, 0x31100c3, 256},
// width does not have to match the maximum value (e.g. rescaling)
{"0.1111 [64,128] => {0x07, 0x3, 0x07}", SkFloatToFixed(0.1111f), 64, 0x1cc007, 128},
{"0.1111 [64,256] => {0x07, 0x3, 0x07}", SkFloatToFixed(0.1111f), 64, 0x1cc007, 256},
{"0.1111 [64,512] => {0x07, 0x3, 0x07}", SkFloatToFixed(0.1111f), 64, 0x1cc007, 512},
{"0.1111 [64, 32] => {0x07, 0x3, 0x09}", SkFloatToFixed(0.1111f), 64, 0x1cc009, 32},
{"0.1111 [64, 8] => {0x07, 0x3, 0x0f}", SkFloatToFixed(0.1111f), 64, 0x1cc00f, 8},
};
constexpr size_t NUM_TESTS = sizeof(tests) / sizeof(TestCase);
for (size_t i = 0; i < NUM_TESTS; i++) {
TestCase tc = tests[i];
uint32_t rv = sktests::pack_mirror(tc.input, tc.max, tc.width);
uint32_t exp = tc.expectedOutput;
REPORTER_ASSERT(r, rv == tc.expectedOutput,
"%s | %x != %x | {%x, %x, %x} != {%x, %x, %x}\n",
tc.name.c_str(), rv, exp,
highBits(rv), middleBits(rv), lowBits(rv),
highBits(exp), middleBits(exp), lowBits(exp));
}
}
DEF_TEST(MatrixProcs_unpack_int, r) {
struct TestCase {
std::string name;
uint32_t input;
int expectedLowerBound;
int expectedLerp;
int expectedUpperBound;
};
// These are selected from earlier tests to make sure the packed values unpack correctly.
TestCase tests[] = {
{"0x000000 => {0x00, 0x0, 0x00}", 0x000000, 0x00, 0x0, 0x00},
{"0x074002 => {0x01, 0xd, 0x02}", 0x074002, 0x01, 0xd, 0x02},
{"0x15c006 => {0x05, 0x7, 0x06}", 0x15c006, 0x05, 0x7, 0x06},
{"0x1d0008 => {0x07, 0x4, 0x08}", 0x1d0008, 0x07, 0x4, 0x08},
{"0x24000a => {0x09, 0x0, 0x0a}", 0x24000a, 0x09, 0x0, 0x0a},
{"0xfc003f => {0x3f, 0x0, 0x3f}", 0xfc003f, 0x3f, 0x0, 0x3f},
{"0x4000100 => {0x100, 0x0, 0x100}", 0x4000100, 0x100, 0x0, 0x100},
};
constexpr size_t NUM_TESTS = sizeof(tests) / sizeof(TestCase);
for (size_t i = 0; i < NUM_TESTS; i++) {
TestCase tc = tests[i];
int lower, upper, lerp;
sktests::decode_packed_coordinates_and_weight(tc.input, &lower, &upper, &lerp);
REPORTER_ASSERT(r, lower == tc.expectedLowerBound,
"%s lower %x != %x", tc.name.c_str(), lower, tc.expectedLowerBound);
REPORTER_ASSERT(r, lerp == tc.expectedLerp,
"%s lerp %x != %x", tc.name.c_str(), lerp, tc.expectedLerp);
REPORTER_ASSERT(r, upper == tc.expectedUpperBound,
"%s upper %x != %x", tc.name.c_str(), upper, tc.expectedUpperBound);
// Make sure our helpers work as expected.
SkASSERT(tc.expectedLowerBound == highBits(tc.input));
SkASSERT(tc.expectedLerp == middleBits(tc.input));
SkASSERT(tc.expectedUpperBound == lowBits(tc.input));
}
}