Debian Codegraph @

lib/jxl/base/common.h

raw
1 // Copyright (c) the JPEG XL Project Authors. All rights reserved.
2 //
3 // Use of this source code is governed by a BSD-style
4 // license that can be found in the LICENSE file.
5
6 #ifndef LIB_JXL_BASE_COMMON_H_
7 #define LIB_JXL_BASE_COMMON_H_
8
9 // Shared constants and helper functions.
10
11 #include <array>
12 #include <cstddef>
13 #include <cstdint>
14 #include <cstdio>
15 #include <memory>
16 #include <string>
17 #include <type_traits>
18
19 #include "lib/jxl/base/compiler_specific.h"
20
21 namespace jxl {
22 // Some enums and typedefs used by more than one header file.
23
24 constexpr size_t kBitsPerByte = 8; // more clear than CHAR_BIT
25
26 constexpr inline size_t RoundUpBitsToByteMultiple(size_t bits) {
27 return (bits + 7) & ~static_cast<size_t>(7);
28 }
29
30 constexpr inline size_t RoundUpToBlockDim(size_t dim) {
31 return (dim + 7) & ~static_cast<size_t>(7);
32 }
33
34 static inline bool JXL_MAYBE_UNUSED SafeAdd(const uint64_t a, const uint64_t b,
35 uint64_t& sum) {
36 sum = a + b;
37 return sum >= a; // no need to check b - either sum >= both or < both.
38 }
39
40 template <typename T1, typename T2>
41 constexpr inline T1 DivCeil(T1 a, T2 b) {
42 return (a + b - 1) / b;
43 }
44
45 // Works for any `align`; if a power of two, compiler emits ADD+AND.
46 constexpr inline size_t RoundUpTo(size_t what, size_t align) {
47 return DivCeil(what, align) * align;
48 }
49
50 constexpr double kPi = 3.14159265358979323846264338327950288;
51
52 // Reasonable default for sRGB, matches common monitors. We map white to this
53 // many nits (cd/m^2) by default. Butteraugli was tuned for 250 nits, which is
54 // very close.
55 // NB: This constant is not very "base", but it is shared between modules.
56 static constexpr float kDefaultIntensityTarget = 255;
57
58 template <typename T>
59 constexpr T Pi(T multiplier) {
60 return static_cast<T>(multiplier * kPi);
61 }
62
63 // Prior to C++14 (i.e. C++11): provide our own make_unique
64 #if __cplusplus < 201402L
65 template <typename T, typename... Args>
66 std::unique_ptr<T> make_unique(Args&&... args) {
67 return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
68 }
69 #else
70 using std::make_unique;
71 #endif
72
73 typedef std::array<float, 3> Color;
74
75 // Backported std::experimental::to_array
76
77 template <typename T>
78 using remove_cv_t = typename std::remove_cv<T>::type;
79
80 template <size_t... I>
81 struct index_sequence {};
82
83 template <size_t N, size_t... I>
84 struct make_index_sequence : make_index_sequence<N - 1, N - 1, I...> {};
85
86 template <size_t... I>
87 struct make_index_sequence<0, I...> : index_sequence<I...> {};
88
89 namespace detail {
90
91 template <typename T, size_t N, size_t... I>
92 constexpr auto to_array(T (&&arr)[N], index_sequence<I...> _)
93 -> std::array<remove_cv_t<T>, N> {
94 return {{std::move(arr[I])...}};
95 }
96
97 } // namespace detail
98
99 template <typename T, size_t N>
100 constexpr auto to_array(T (&&arr)[N]) -> std::array<remove_cv_t<T>, N> {
101 return detail::to_array(std::move(arr), make_index_sequence<N>());
102 }
103
104 template <typename T>
105 JXL_INLINE T Clamp1(T val, T low, T hi) {
106 return val < low ? low : val > hi ? hi : val;
107 }
108
109 // conversion from integer to string.
110 template <typename T>
111 std::string ToString(T n) {
112 char data[32] = {};
113 if (std::is_floating_point<T>::value) {
114 // float
115 snprintf(data, sizeof(data), "%g", static_cast<double>(n));
116 } else if (std::is_unsigned<T>::value) {
117 // unsigned
118 snprintf(data, sizeof(data), "%llu", static_cast<unsigned long long>(n));
119 } else {
120 // signed
121 snprintf(data, sizeof(data), "%lld", static_cast<long long>(n));
122 }
123 return data;
124 }
125
126 #define JXL_JOIN(x, y) JXL_DO_JOIN(x, y)
127 #define JXL_DO_JOIN(x, y) x##y
128
129 } // namespace jxl
130
131 #endif // LIB_JXL_BASE_COMMON_H_