Debian Codegraph @

src/openmpt/soundbase/SampleConvertFixedPoint.hpp

raw
1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /* SPDX-FileCopyrightText: OpenMPT Project Developers and Contributors */
3
4
5 #pragma once
6
7 #include "openmpt/all/BuildSettings.hpp"
8
9 #include "mpt/base/arithmetic_shift.hpp"
10 #include "mpt/base/macros.hpp"
11 #include "mpt/base/math.hpp"
12 #include "mpt/base/saturate_cast.hpp"
13 #include "openmpt/base/Int24.hpp"
14 #include "openmpt/base/Types.hpp"
15 #include "openmpt/soundbase/SampleConvert.hpp"
16
17 #include <algorithm>
18 #include <limits>
19
20
21
22 OPENMPT_NAMESPACE_BEGIN
23
24
25 namespace SC
26 { // SC = _S_ample_C_onversion
27
28
29 template <typename Tdst, typename Tsrc, int fractionalBits>
30 struct ConvertFixedPoint;
31
32 template <int fractionalBits>
33 struct ConvertFixedPoint<uint8, int32, fractionalBits>
34 {
35 using input_t = int32;
36 using output_t = uint8;
37 static constexpr int shiftBits = fractionalBits + 1 - sizeof(output_t) * 8;
38 MPT_FORCEINLINE output_t operator()(input_t val)
39 {
40 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(input_t) * 8 - 1);
41 static_assert(shiftBits >= 1);
42 val = mpt::rshift_signed((val + (1 << (shiftBits - 1))), shiftBits); // round
43 if(val < std::numeric_limits<int8>::min()) val = std::numeric_limits<int8>::min();
44 if(val > std::numeric_limits<int8>::max()) val = std::numeric_limits<int8>::max();
45 return static_cast<uint8>(val + 0x80); // unsigned
46 }
47 };
48
49 template <int fractionalBits>
50 struct ConvertFixedPoint<int8, int32, fractionalBits>
51 {
52 using input_t = int32;
53 using output_t = int8;
54 static constexpr int shiftBits = fractionalBits + 1 - sizeof(output_t) * 8;
55 MPT_FORCEINLINE output_t operator()(input_t val)
56 {
57 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(input_t) * 8 - 1);
58 static_assert(shiftBits >= 1);
59 val = mpt::rshift_signed((val + (1 << (shiftBits - 1))), shiftBits); // round
60 if(val < std::numeric_limits<int8>::min()) val = std::numeric_limits<int8>::min();
61 if(val > std::numeric_limits<int8>::max()) val = std::numeric_limits<int8>::max();
62 return static_cast<int8>(val);
63 }
64 };
65
66 template <int fractionalBits>
67 struct ConvertFixedPoint<int16, int32, fractionalBits>
68 {
69 using input_t = int32;
70 using output_t = int16;
71 static constexpr int shiftBits = fractionalBits + 1 - sizeof(output_t) * 8;
72 MPT_FORCEINLINE output_t operator()(input_t val)
73 {
74 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(input_t) * 8 - 1);
75 static_assert(shiftBits >= 1);
76 val = mpt::rshift_signed((val + (1 << (shiftBits - 1))), shiftBits); // round
77 if(val < std::numeric_limits<int16>::min()) val = std::numeric_limits<int16>::min();
78 if(val > std::numeric_limits<int16>::max()) val = std::numeric_limits<int16>::max();
79 return static_cast<int16>(val);
80 }
81 };
82
83 template <int fractionalBits>
84 struct ConvertFixedPoint<int24, int32, fractionalBits>
85 {
86 using input_t = int32;
87 using output_t = int24;
88 static constexpr int shiftBits = fractionalBits + 1 - sizeof(output_t) * 8;
89 MPT_FORCEINLINE output_t operator()(input_t val)
90 {
91 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(input_t) * 8 - 1);
92 static_assert(shiftBits >= 1);
93 val = mpt::rshift_signed((val + (1 << (shiftBits - 1))), shiftBits); // round
94 if(val < std::numeric_limits<int24>::min()) val = std::numeric_limits<int24>::min();
95 if(val > std::numeric_limits<int24>::max()) val = std::numeric_limits<int24>::max();
96 return static_cast<int24>(val);
97 }
98 };
99
100 template <int fractionalBits>
101 struct ConvertFixedPoint<int32, int32, fractionalBits>
102 {
103 using input_t = int32;
104 using output_t = int32;
105 MPT_FORCEINLINE output_t operator()(input_t val)
106 {
107 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(input_t) * 8 - 1);
108 return static_cast<int32>(std::clamp(val, static_cast<int32>(-((1 << fractionalBits) - 1)), static_cast<int32>(1 << fractionalBits) - 1)) << (sizeof(input_t) * 8 - 1 - fractionalBits);
109 }
110 };
111
112 template <int fractionalBits>
113 struct ConvertFixedPoint<somefloat32, int32, fractionalBits>
114 {
115 using input_t = int32;
116 using output_t = somefloat32;
117 const float factor;
118 MPT_FORCEINLINE ConvertFixedPoint()
119 : factor(1.0f / static_cast<float>(1 << fractionalBits))
120 {
121 return;
122 }
123 MPT_FORCEINLINE output_t operator()(input_t val)
124 {
125 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(input_t) * 8 - 1);
126 return static_cast<somefloat32>(val) * factor;
127 }
128 };
129
130 template <int fractionalBits>
131 struct ConvertFixedPoint<somefloat64, int32, fractionalBits>
132 {
133 using input_t = int32;
134 using output_t = somefloat64;
135 const double factor;
136 MPT_FORCEINLINE ConvertFixedPoint()
137 : factor(1.0 / static_cast<double>(1 << fractionalBits))
138 {
139 return;
140 }
141 MPT_FORCEINLINE output_t operator()(input_t val)
142 {
143 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(input_t) * 8 - 1);
144 return static_cast<somefloat64>(val) * factor;
145 }
146 };
147
148
149 template <typename Tdst, typename Tsrc, int fractionalBits>
150 struct ConvertToFixedPoint;
151
152 template <int fractionalBits>
153 struct ConvertToFixedPoint<int32, uint8, fractionalBits>
154 {
155 using input_t = uint8;
156 using output_t = int32;
157 static constexpr int shiftBits = fractionalBits + 1 - sizeof(input_t) * 8;
158 MPT_FORCEINLINE output_t operator()(input_t val)
159 {
160 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(output_t) * 8 - 1);
161 static_assert(shiftBits >= 1);
162 return mpt::lshift_signed(static_cast<output_t>(static_cast<int>(val) - 0x80), shiftBits);
163 }
164 };
165
166 template <int fractionalBits>
167 struct ConvertToFixedPoint<int32, int8, fractionalBits>
168 {
169 using input_t = int8;
170 using output_t = int32;
171 static constexpr int shiftBits = fractionalBits + 1 - sizeof(input_t) * 8;
172 MPT_FORCEINLINE output_t operator()(input_t val)
173 {
174 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(output_t) * 8 - 1);
175 static_assert(shiftBits >= 1);
176 return mpt::lshift_signed(static_cast<output_t>(val), shiftBits);
177 }
178 };
179
180 template <int fractionalBits>
181 struct ConvertToFixedPoint<int32, int16, fractionalBits>
182 {
183 using input_t = int16;
184 using output_t = int32;
185 static constexpr int shiftBits = fractionalBits + 1 - sizeof(input_t) * 8;
186 MPT_FORCEINLINE output_t operator()(input_t val)
187 {
188 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(output_t) * 8 - 1);
189 static_assert(shiftBits >= 1);
190 return mpt::lshift_signed(static_cast<output_t>(val), shiftBits);
191 }
192 };
193
194 template <int fractionalBits>
195 struct ConvertToFixedPoint<int32, int24, fractionalBits>
196 {
197 using input_t = int24;
198 using output_t = int32;
199 static constexpr int shiftBits = fractionalBits + 1 - sizeof(input_t) * 8;
200 MPT_FORCEINLINE output_t operator()(input_t val)
201 {
202 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(output_t) * 8 - 1);
203 static_assert(shiftBits >= 1);
204 return mpt::lshift_signed(static_cast<output_t>(val), shiftBits);
205 }
206 };
207
208 template <int fractionalBits>
209 struct ConvertToFixedPoint<int32, int32, fractionalBits>
210 {
211 using input_t = int32;
212 using output_t = int32;
213 MPT_FORCEINLINE output_t operator()(input_t val)
214 {
215 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(output_t) * 8 - 1);
216 return mpt::rshift_signed(static_cast<output_t>(val), (sizeof(input_t) * 8 - 1 - fractionalBits));
217 }
218 };
219
220 template <int fractionalBits>
221 struct ConvertToFixedPoint<int32, somefloat32, fractionalBits>
222 {
223 using input_t = somefloat32;
224 using output_t = int32;
225 const float factor;
226 MPT_FORCEINLINE ConvertToFixedPoint()
227 : factor(static_cast<float>(1 << fractionalBits))
228 {
229 return;
230 }
231 MPT_FORCEINLINE output_t operator()(input_t val)
232 {
233 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(input_t) * 8 - 1);
234 val = mpt::sanitize_nan(val);
235 return mpt::saturate_trunc<output_t>(SC::fastround(val * factor));
236 }
237 };
238
239 template <int fractionalBits>
240 struct ConvertToFixedPoint<int32, somefloat64, fractionalBits>
241 {
242 using input_t = somefloat64;
243 using output_t = int32;
244 const double factor;
245 MPT_FORCEINLINE ConvertToFixedPoint()
246 : factor(static_cast<double>(1 << fractionalBits))
247 {
248 return;
249 }
250 MPT_FORCEINLINE output_t operator()(input_t val)
251 {
252 static_assert(fractionalBits >= 0 && fractionalBits <= sizeof(input_t) * 8 - 1);
253 val = mpt::sanitize_nan(val);
254 return mpt::saturate_trunc<output_t>(SC::fastround(val * factor));
255 }
256 };
257
258
259 } // namespace SC
260
261
262 OPENMPT_NAMESPACE_END