dolphin-emu/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-10-07 07:43:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

MathUtil: Add SaturatingCast to cast floats more safely

Browse Source
This commit is contained in:
Léo Lam 2021-01-28 12:45:50 +01:00
parent ac250f7c20
commit 48712168b8
No known key found for this signature in database
GPG Key ID: 0DF30F9081000741
2 changed files with 85 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
Source/Core/Common/MathUtil.h
View File

@ -6,6 +6,7 @@
#include <algorithm>
#include <cmath>
#include <limits>
#include <type_traits>
#include <vector>
@ -30,6 +31,48 @@ constexpr auto Lerp(const T& x, const T& y, const F& a) -> decltype(x + (y - x)
return x + (y - x) * a;
}
// Casts the specified value to a Dest. The value will be clamped to fit in the destination type.
// Warning: The result of SaturatingCast(NaN) is undefined.
template <typename Dest, typename T>
constexpr Dest SaturatingCast(T value)
{
static_assert(std::is_integral<Dest>());
constexpr Dest lo = std::numeric_limits<Dest>::lowest();
constexpr Dest hi = std::numeric_limits<Dest>::max();
// T being a signed integer and Dest unsigned is a problematic case because the value will
// be converted into an unsigned integer, and u32(...) < 0 is always false.
if constexpr (std::is_integral<T>() && std::is_signed<T>() && std::is_unsigned<Dest>())
{
static_assert(lo == 0);
if (value < 0)
return lo;
// Now that we got rid of negative values, we can safely cast value to an unsigned T
// since unsigned T can represent any positive value signed T could represent.
// The compiler will then promote the LHS or the RHS if necessary.
if (std::make_unsigned_t<T>(value) > hi)
return hi;
}
else if constexpr (std::is_integral<T>() && std::is_unsigned<T>() && std::is_signed<Dest>())
{
// value and hi will never be negative, and hi is representable as an unsigned Dest.
if (value > std::make_unsigned_t<Dest>(hi))
return hi;
}
else
{
// Do not use std::clamp or a similar function here to avoid overflow.
// For example, if Dest = s64 and T = int, we want integer promotion to convert value to a s64
// instead of changing lo or hi into an int.
if (value < lo)
return lo;
if (value > hi)
return hi;
}
return static_cast<Dest>(value);
}
template <typename T>
constexpr bool IsPow2(T imm)
{

42
Source/UnitTests/Common/MathUtilTest.cpp
View File

@ -26,3 +26,45 @@ TEST(MathUtil, NextPowerOf2)
EXPECT_EQ(8U, MathUtil::NextPowerOf2(6));
EXPECT_EQ(0x40000000U, MathUtil::NextPowerOf2(0x23456789));
}
TEST(MathUtil, SaturatingCast)
{
// Cast from an integer type to a smaller type
EXPECT_EQ(255u, (MathUtil::SaturatingCast<u8, int>(1000)));
EXPECT_EQ(255u, (MathUtil::SaturatingCast<u8, u16>(1000u)));
EXPECT_EQ(255u, (MathUtil::SaturatingCast<u8, std::size_t>(1000)));
// Cast from a signed integer type
EXPECT_EQ(0u, (MathUtil::SaturatingCast<u8, int>(-1)));
EXPECT_EQ(0u, (MathUtil::SaturatingCast<u8, int>(-1000)));
EXPECT_EQ(0u, (MathUtil::SaturatingCast<u32, int>(-1)));
EXPECT_EQ(-1000, (MathUtil::SaturatingCast<s16, int>(-1000)));
EXPECT_EQ(-1000, (MathUtil::SaturatingCast<int, int>(-1000)));
EXPECT_EQ(-1000, (MathUtil::SaturatingCast<s64, int>(-1000)));
// Cast from an unsigned integer type to a smaller integer type
EXPECT_EQ(0x7fff, (MathUtil::SaturatingCast<s16, u32>(0xffffffffu)));
EXPECT_EQ(0x7fffffff, (MathUtil::SaturatingCast<int, u32>(0xffffffffu)));
// Cast from a floating point type to an integer type
EXPECT_EQ(255u, MathUtil::SaturatingCast<u8>(1234.0));
EXPECT_EQ(0u, MathUtil::SaturatingCast<u8>(-1234.0));
EXPECT_EQ(127, MathUtil::SaturatingCast<s8>(5678.0));
EXPECT_EQ(-128, MathUtil::SaturatingCast<s8>(-5678.0));
EXPECT_EQ(65535u, MathUtil::SaturatingCast<u16>(999999.0));
// Negative zero
EXPECT_EQ(0u, MathUtil::SaturatingCast<u8>(0.0));
EXPECT_EQ(0u, MathUtil::SaturatingCast<u8>(-0.0));
EXPECT_EQ(0, MathUtil::SaturatingCast<s8>(0.0));
EXPECT_EQ(0, MathUtil::SaturatingCast<s8>(-0.0));
// Edge cases
EXPECT_EQ(std::numeric_limits<s32>::max(),
MathUtil::SaturatingCast<s32>(std::numeric_limits<float>::infinity()));
EXPECT_EQ(std::numeric_limits<s32>::min(),
MathUtil::SaturatingCast<s32>(-std::numeric_limits<float>::infinity()));
// 16777217 = 2^24 + 1 is the first integer that cannot be represented correctly with a f32.
EXPECT_EQ(16777216, MathUtil::SaturatingCast<s32>(float(16777216)));
EXPECT_EQ(16777216, MathUtil::SaturatingCast<s32>(float(16777217)));
}