1#![allow(dead_code)]
2
3pub mod mod_i24;
4pub mod mod_u24;
5
6pub use mod_i24::*;
7pub use mod_u24::*;
8
9use std::{any::type_name, io::{Read, Write, Error}, mem::size_of, fmt::Debug, clone::Clone};
10use std::ops::{Add, Sub, Mul, Div, AddAssign, SubAssign, MulAssign, DivAssign};
11use std::ops::{BitAnd, BitOr, BitXor, Shl, Shr, BitAndAssign, BitOrAssign, BitXorAssign, ShlAssign, ShrAssign};
12use std::ops::{Rem, RemAssign};
13use std::ops::{Neg};
14
15pub trait Numeric:
16Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self> + Div<Output = Self> +
17AddAssign + SubAssign + MulAssign + DivAssign +
18Debug + Sized + Clone + Copy + 'static {}
19
20impl<T> Numeric for T where T:
21Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self> + Div<Output = Self> +
22AddAssign + SubAssign + MulAssign + DivAssign +
23Debug + Sized + Clone + Copy + 'static {}
24
25pub trait SampleTypeInteger:
26SampleType +
27BitAnd<Output = Self> +
28BitOr<Output = Self> +
29BitXor<Output = Self> +
30Shl<Output = Self> +
31Shr<Output = Self> +
32BitAndAssign +
33BitOrAssign +
34BitXorAssign +
35ShlAssign +
36ShrAssign +
37Rem<Output = Self> +
38RemAssign {}
39
40impl<T> SampleTypeInteger for T where T:
41SampleType +
42BitAnd<Output = Self> +
43BitOr<Output = Self> +
44BitXor<Output = Self> +
45Shl<Output = Self> +
46Shr<Output = Self> +
47BitAndAssign +
48BitOrAssign +
49BitXorAssign +
50ShlAssign +
51ShrAssign +
52Rem<Output = Self> +
53RemAssign {}
54
55pub trait SampleTypeIntegerSigned: SampleTypeInteger + Neg {}
56impl<T> SampleTypeIntegerSigned for T where T: SampleTypeInteger + Neg {}
57
58macro_rules! mid_number {
59 (i8) => {0i8};
60 (i16) => {0i16};
61 (i24) => {i24(0, 0, 0)};
62 (i32) => {0i32};
63 (i64) => {0i64};
64 (i128) => {0i128};
65 (u8) => {0x80u8};
66 (u16) => {0x8000u16};
67 (u24) => {u24(0, 0, 0x80)};
68 (u32) => {0x80000000u32};
69 (u64) => {0x80000000_00000000u64};
70 (u128) => {0x80000000_00000000_00000000_00000000u128};
71 (f32) => {0.0f32};
72 (f64) => {0.0f64};
73}
74
75macro_rules! zero_number {
76 (i8) => {0i8};
77 (i16) => {0i16};
78 (i24) => {i24(0, 0, 0)};
79 (i32) => {0i32};
80 (i64) => {0i64};
81 (i128) => {0i128};
82 (u8) => {0u8};
83 (u16) => {0u16};
84 (u24) => {u24(0, 0, 0)};
85 (u32) => {0u32};
86 (u64) => {0u64};
87 (u128) => {0u128};
88 (f32) => {0.0f32};
89 (f64) => {0.0f64};
90}
91
92macro_rules! sizeof {
93 (i8 ) => {1 };
94 (i16 ) => {2 };
95 (i24 ) => {3 };
96 (i32 ) => {4 };
97 (i64 ) => {8 };
98 (i128) => {16};
99 (u8 ) => {1 };
100 (u16 ) => {2 };
101 (u24 ) => {3 };
102 (u32 ) => {4 };
103 (u64 ) => {8 };
104 (u128) => {16};
105 (f32 ) => {4 };
106 (f64 ) => {8 };
107}
108
109macro_rules! signed_type {
110 (i8 ) => {i8 };
111 (i16 ) => {i16 };
112 (i24 ) => {i24 };
113 (i32 ) => {i32 };
114 (i64 ) => {i64 };
115 (i128) => {i128};
116 (u8 ) => {i8 };
117 (u16 ) => {i16 };
118 (u24 ) => {i24 };
119 (u32 ) => {i32 };
120 (u64 ) => {i64 };
121 (u128) => {i128};
122 (f32 ) => {f32 };
123 (f64 ) => {f64 };
124}
125
126macro_rules! unsigned_type {
127 (i8 ) => {u8 };
128 (i16 ) => {u16 };
129 (i24 ) => {u24 };
130 (i32 ) => {u32 };
131 (i64 ) => {u64 };
132 (i128) => {u128};
133 (u8 ) => {u8 };
134 (u16 ) => {u16 };
135 (u24 ) => {u24 };
136 (u32 ) => {u32 };
137 (u64 ) => {u64 };
138 (u128) => {u128};
139 (f32 ) => {f32 };
140 (f64 ) => {f64 };
141}
142
143macro_rules! is_signed {
144 (i8 ) => {true };
145 (i16 ) => {true };
146 (i24 ) => {true };
147 (i32 ) => {true };
148 (i64 ) => {true };
149 (i128) => {true };
150 (u8 ) => {false};
151 (u16 ) => {false};
152 (u24 ) => {false};
153 (u32 ) => {false};
154 (u64 ) => {false};
155 (u128) => {false};
156 (f32 ) => {true };
157 (f64 ) => {true };
158}
159
160macro_rules! is_unsigned {
161 ($tp:tt) => {!is_signed!($tp)};
162}
163
164macro_rules! to_signed {
165 (i8 , $v:expr) => {$v};
166 (i16 , $v:expr) => {$v};
167 (i24 , $v:expr) => {$v};
168 (i32 , $v:expr) => {$v};
169 (i64 , $v:expr) => {$v};
170 (i128, $v:expr) => {$v};
171 (u8 , $v:expr) => {$v.wrapping_sub(mid_number!(u8 )) as i8 };
172 (u16 , $v:expr) => {$v.wrapping_sub(mid_number!(u16 )) as i16 };
173 (u24 , $v:expr) => {i24($v.0, $v.1, to_signed!(u8, $v.2) as u8)};
174 (u32 , $v:expr) => {$v.wrapping_sub(mid_number!(u32 )) as i32 };
175 (u64 , $v:expr) => {$v.wrapping_sub(mid_number!(u64 )) as i64 };
176 (u128, $v:expr) => {$v.wrapping_sub(mid_number!(u128)) as i128};
177 (f32 , $v:expr) => {$v};
178 (f64 , $v:expr) => {$v};
179}
180
181macro_rules! to_unsigned {
182 (i8 , $v:expr) => {($v as u8 ).wrapping_add(mid_number!(u8 ))};
183 (i16 , $v:expr) => {($v as u16 ).wrapping_add(mid_number!(u16 ))};
184 (i24 , $v:expr) => {u24($v.0, $v.1, to_unsigned!(i8, $v.2 as i8))};
185 (i32 , $v:expr) => {($v as u32 ).wrapping_add(mid_number!(u32 ))};
186 (i64 , $v:expr) => {($v as u64 ).wrapping_add(mid_number!(u64 ))};
187 (i128, $v:expr) => {($v as u128).wrapping_add(mid_number!(u128))};
188 (u8 , $v:expr) => {$v};
189 (u16 , $v:expr) => {$v};
190 (u24 , $v:expr) => {$v};
191 (u32 , $v:expr) => {$v};
192 (u64 , $v:expr) => {$v};
193 (u128, $v:expr) => {$v};
194 (f32 , $v:expr) => {$v};
195 (f64 , $v:expr) => {$v};
196}
197
198macro_rules! is_integer {
199 (i8 ) => {true };
200 (i16 ) => {true };
201 (i24 ) => {true };
202 (i32 ) => {true };
203 (i64 ) => {true };
204 (i128) => {true };
205 (u8 ) => {true };
206 (u16 ) => {true };
207 (u24 ) => {true };
208 (u32 ) => {true };
209 (u64 ) => {true };
210 (u128) => {true };
211 (f32 ) => {false};
212 (f64 ) => {false};
213}
214
215macro_rules! is_float {
216 ($tp:tt) => {!is_integer!($tp)};
217}
218
219macro_rules! longer_type {
220 (i8 ) => {i16 };
221 (i16 ) => {i24 };
222 (i24 ) => {i32 };
223 (i32 ) => {i64 };
224 (i64 ) => {i128};
225 (i128) => {i128};
226 (u8 ) => {u16 };
227 (u16 ) => {u24 };
228 (u24 ) => {u32 };
229 (u32 ) => {u64 };
230 (u64 ) => {u128};
231 (u128) => {u128};
232 (f32 ) => {f64 };
233 (f64 ) => {f64 };
234}
235
236macro_rules! shorter_type {
237 (i8 ) => {i8 };
238 (i16 ) => {i8 };
239 (i24 ) => {i16};
240 (i32 ) => {i24};
241 (i64 ) => {i32};
242 (i128) => {i64};
243 (u8 ) => {u8 };
244 (u16 ) => {u8 };
245 (u24 ) => {u16};
246 (u32 ) => {u24};
247 (u64 ) => {u32};
248 (u128) => {u64};
249 (f32 ) => {f32};
250 (f64 ) => {f32};
251}
252
253macro_rules! as_longer {
254 (i8 , $v:expr) => {$v as i16};
255 (i16 , $v:expr) => {<i24 as From>::from($v)};
256 (i24 , $v:expr) => {$v.as_i32()};
257 (i32 , $v:expr) => {$v as i64};
258 (i64 , $v:expr) => {$v as i128};
259 (i128, $v:expr) => {$v as i128};
260 (u8 , $v:expr) => {$v as u16};
261 (u16 , $v:expr) => {u24::from($v)};
262 (u24 , $v:expr) => {$v.as_u32()};
263 (u32 , $v:expr) => {$v as u64};
264 (u64 , $v:expr) => {$v as u128};
265 (u128, $v:expr) => {$v as u128};
266 (f32 , $v:expr) => {$v as f64};
267 (f64 , $v:expr) => {$v as f64};
268}
269
270#[allow(unused_macros)]
271macro_rules! as_shorter {
272 (i8 , $v:expr) => {$v as i8};
273 (i16 , $v:expr) => {$v as i8};
274 (i24 , $v:expr) => {$v.as_i16()};
275 (i32 , $v:expr) => {<i24 as From>::from($v)};
276 (i64 , $v:expr) => {$v as i32};
277 (i128, $v:expr) => {$v as i64};
278 (u8 , $v:expr) => {$v as u8};
279 (u16 , $v:expr) => {$v as u8};
280 (u24 , $v:expr) => {$v.as_u16()};
281 (u32 , $v:expr) => {u24::from($v)};
282 (u64 , $v:expr) => {$v as u32};
283 (u128, $v:expr) => {$v as u64};
284 (f32 , $v:expr) => {$v as f32};
285 (f64 , $v:expr) => {$v as f32};
286}
287
288macro_rules! to_longer {
289 (i8 , $v:expr) => {{let longer = as_longer!(i8, $v); (longer << 8) | (to_unsigned!(i16, longer) as i16)}};
290 (i16 , $v:expr) => {{let b = $v.to_le_bytes(); i24(to_unsigned!(i8, b[1] as i8), b[0], b[1])}};
291 (i24 , $v:expr) => {($v.as_i32() << 8) | (to_unsigned!(i8, $v.2 as i8) as i32)};
292 (i32 , $v:expr) => {{let longer = as_longer!(i32, $v); (longer << 32) | (to_unsigned!(i64, longer) as i64)}};
293 (i64 , $v:expr) => {{let longer = as_longer!(i64, $v); (longer << 64) | (to_unsigned!(i128, longer) as i128)}};
294 (i128, $v:expr) => {$v};
295 (u8 , $v:expr) => {{let longer = as_longer!(u8, $v); (longer << 8) | (longer as u16)}};
296 (u16 , $v:expr) => {{let b = $v.to_le_bytes(); u24(b[1], b[0], b[1])}};
297 (u24 , $v:expr) => {($v.as_u32() << 8) | ($v.2 as u32)};
298 (u32 , $v:expr) => {{let longer = as_longer!(u32, $v); (longer << 32) | (longer as u64)}};
299 (u64 , $v:expr) => {{let longer = as_longer!(u64, $v); (longer << 64) | (longer as u128)}};
300 (u128, $v:expr) => {$v};
301 (f32 , $v:expr) => {$v as f64};
302 (f64 , $v:expr) => {$v};
303}
304
305macro_rules! to_shorter {
306 (i8 , $v:expr) => {$v};
307 (i16 , $v:expr) => {($v >> 8) as i8};
308 (i24 , $v:expr) => {i16::from_le_bytes([$v.1, $v.2])};
309 (i32 , $v:expr) => {<i24 as From<i32>>::from($v >> 8)};
310 (i64 , $v:expr) => {($v >> 32) as i32};
311 (i128, $v:expr) => {($v >> 64) as i64};
312 (u8 , $v:expr) => {$v};
313 (u16 , $v:expr) => {($v >> 8) as u8};
314 (u24 , $v:expr) => {u16::from_le_bytes([$v.1, $v.2])};
315 (u32 , $v:expr) => {<u24 as From<u32>>::from($v >> 8)};
316 (u64 , $v:expr) => {($v >> 32) as u32};
317 (u128, $v:expr) => {($v >> 64) as u64};
318 (f32 , $v:expr) => {$v};
319 (f64 , $v:expr) => {$v as f32};
320}
321
322macro_rules! to_i8 {
323 (i8 , $v:expr) => {$v};
324 (i16 , $v:expr) => {($v >> 8) as i8};
325 (i24 , $v:expr) => {$v.2 as i8};
326 (i32 , $v:expr) => {($v >> 24) as i8};
327 (i64 , $v:expr) => {($v >> 56) as i8};
328 (i128, $v:expr) => {($v >> 120) as i8};
329 (u8 , $v:expr) => {to_i8!(i8 , to_signed!(u8 , $v))};
330 (u16 , $v:expr) => {to_i8!(i16 , to_signed!(u16 , $v))};
331 (u24 , $v:expr) => {to_i8!(i24 , to_signed!(u24 , $v))};
332 (u32 , $v:expr) => {to_i8!(i32 , to_signed!(u32 , $v))};
333 (u64 , $v:expr) => {to_i8!(i64 , to_signed!(u64 , $v))};
334 (u128, $v:expr) => {to_i8!(i128, to_signed!(u128, $v))};
335 (f32 , $v:expr) => {($v * i8::MAX as f32) as i8};
336 (f64 , $v:expr) => {($v * i8::MAX as f64) as i8};
337}
338
339macro_rules! to_i16 {
340 (i8 , $v:expr) => {to_longer!(i8, $v)};
341 (i16 , $v:expr) => {$v};
342 (i24 , $v:expr) => {to_shorter!(i24, $v)};
343 (i32 , $v:expr) => {($v >> 16) as i16};
344 (i64 , $v:expr) => {($v >> 48) as i16};
345 (i128, $v:expr) => {($v >> 112) as i16};
346 (u8 , $v:expr) => {to_i16!(i8 , to_signed!(u8 , $v))};
347 (u16 , $v:expr) => {to_i16!(i16 , to_signed!(u16 , $v))};
348 (u24 , $v:expr) => {to_i16!(i24 , to_signed!(u24 , $v))};
349 (u32 , $v:expr) => {to_i16!(i32 , to_signed!(u32 , $v))};
350 (u64 , $v:expr) => {to_i16!(i64 , to_signed!(u64 , $v))};
351 (u128, $v:expr) => {to_i16!(i128, to_signed!(u128, $v))};
352 (f32 , $v:expr) => {($v * i16::MAX as f32) as i16};
353 (f64 , $v:expr) => {($v * i16::MAX as f64) as i16};
354}
355
356macro_rules! to_i24 {
357 (i8 , $v:expr) => {{let u = to_unsigned!(i8, $v); i24(u, u, $v as u8)}};
358 (i16 , $v:expr) => {to_longer!(i16, $v)};
359 (i24 , $v:expr) => {$v};
360 (i32 , $v:expr) => {to_shorter!(i32, $v)};
361 (i64 , $v:expr) => {<i24 as From<i64>>::from($v >> 40)};
362 (i128, $v:expr) => {<i24 as From<i128>>::from($v >> 104)};
363 (u8 , $v:expr) => {to_i24!(i8 , to_signed!(u8 , $v))};
364 (u16 , $v:expr) => {to_i24!(i16 , to_signed!(u16 , $v))};
365 (u24 , $v:expr) => {to_i24!(i24 , to_signed!(u24 , $v))};
366 (u32 , $v:expr) => {to_i24!(i32 , to_signed!(u32 , $v))};
367 (u64 , $v:expr) => {to_i24!(i64 , to_signed!(u64 , $v))};
368 (u128, $v:expr) => {to_i24!(i128, to_signed!(u128, $v))};
369 (f32 , $v:expr) => {<i24 as From<i32>>::from(($v * 0x7FFFFF as f32) as i32)};
370 (f64 , $v:expr) => {<i24 as From<i32>>::from(($v * 0x7FFFFF as f64) as i32)};
371}
372
373macro_rules! to_i32 {
374 (i8 , $v:expr) => {{let longer = to_i16!(i8, $v); ((longer as i32) << 16) | (to_unsigned!(i16, longer) as i32)}};
375 (i16 , $v:expr) => {(($v as i32) << 16) | (to_unsigned!(i16, $v) as i32)};
376 (i24 , $v:expr) => {to_longer!(i24, $v)};
377 (i32 , $v:expr) => {$v};
378 (i64 , $v:expr) => {($v >> 32) as i32};
379 (i128, $v:expr) => {($v >> 96) as i32};
380 (u8 , $v:expr) => {to_i32!(i8 , to_signed!(u8 , $v))};
381 (u16 , $v:expr) => {to_i32!(i16 , to_signed!(u16 , $v))};
382 (u24 , $v:expr) => {to_i32!(i24 , to_signed!(u24 , $v))};
383 (u32 , $v:expr) => {to_i32!(i32 , to_signed!(u32 , $v))};
384 (u64 , $v:expr) => {to_i32!(i64 , to_signed!(u64 , $v))};
385 (u128, $v:expr) => {to_i32!(i128, to_signed!(u128, $v))};
386 (f32 , $v:expr) => {($v * i32::MAX as f32) as i32};
387 (f64 , $v:expr) => {($v * i32::MAX as f64) as i32};
388}
389
390macro_rules! to_i64 {
391 (i8 , $v:expr) => {{let longer = to_i32!(i8 , $v); ((longer as i64) << 32) | (to_unsigned!(i32, longer) as i64)}};
392 (i16 , $v:expr) => {{let longer = to_i32!(i16, $v); ((longer as i64) << 32) | (to_unsigned!(i32, longer) as i64)}};
393 (i24 , $v:expr) => {{let u2 = to_unsigned!(i8, $v.2 as i8); i64::from_le_bytes([$v.1, u2, $v.0, $v.1, u2, $v.0, $v.1, $v.2])}};
394 (i32 , $v:expr) => {to_longer!(i32, $v)};
395 (i64 , $v:expr) => {$v};
396 (i128, $v:expr) => {to_shorter!(i128, $v)};
397 (u8 , $v:expr) => {to_i64!(i8 , to_signed!(u8 , $v))};
398 (u16 , $v:expr) => {to_i64!(i16 , to_signed!(u16 , $v))};
399 (u24 , $v:expr) => {i64::from_le_bytes([$v.1, $v.2, $v.0, $v.1, $v.2, $v.0, $v.1, to_signed!(u8, $v.2) as u8])};
400 (u32 , $v:expr) => {to_i64!(i32 , to_signed!(u32 , $v))};
401 (u64 , $v:expr) => {to_i64!(i64 , to_signed!(u64 , $v))};
402 (u128, $v:expr) => {to_i64!(i128, to_signed!(u128, $v))};
403 (f32 , $v:expr) => {($v * i64::MAX as f32) as i64};
404 (f64 , $v:expr) => {($v * i64::MAX as f64) as i64};
405}
406
407macro_rules! to_i128 {
408 (i8 , $v:expr) => {{let longer = to_i64!(i8 , $v); ((longer as i128) << 64) | (to_unsigned!(i64, longer) as i128)}};
409 (i16 , $v:expr) => {{let longer = to_i64!(i16, $v); ((longer as i128) << 64) | (to_unsigned!(i64, longer) as i128)}};
410 (i24 , $v:expr) => {{let u2 = to_unsigned!(i8, $v.2 as i8); i128::from_le_bytes([u2, $v.0, $v.1, u2, $v.0, $v.1, u2, $v.0, $v.1, u2, $v.0, $v.1, u2, $v.0, $v.1, $v.2])}};
411 (i32 , $v:expr) => {{let longer = to_i64!(i32, $v); ((longer as i128) << 64) | (to_unsigned!(i64, longer) as i128)}};
412 (i64 , $v:expr) => {to_longer!(i64, $v)};
413 (i128, $v:expr) => {$v};
414 (u8 , $v:expr) => {to_i128!(i8 , to_signed!(u8 , $v))};
415 (u16 , $v:expr) => {to_i128!(i16 , to_signed!(u16 , $v))};
416 (u24 , $v:expr) => {i128::from_le_bytes([$v.2, $v.0, $v.1, $v.2, $v.0, $v.1, $v.2, $v.0, $v.1, $v.2, $v.0, $v.1, $v.2, $v.0, $v.1, to_signed!(u8, $v.2) as u8])};
417 (u32 , $v:expr) => {to_i128!(i32 , to_signed!(u32 , $v))};
418 (u64 , $v:expr) => {to_i128!(i64 , to_signed!(u64 , $v))};
419 (u128, $v:expr) => {to_i128!(i128, to_signed!(u128, $v))};
420 (f32 , $v:expr) => {($v * i128::MAX as f32) as i128};
421 (f64 , $v:expr) => {($v * i128::MAX as f64) as i128};
422}
423
424macro_rules! to_u8 {
425 (i8 , $v:expr) => {to_unsigned!(i8, to_i8!(i8 , $v))};
426 (i16 , $v:expr) => {to_unsigned!(i8, to_i8!(i16 , $v))};
427 (i24 , $v:expr) => {to_unsigned!(i8, to_i8!(i24 , $v))};
428 (i32 , $v:expr) => {to_unsigned!(i8, to_i8!(i32 , $v))};
429 (i64 , $v:expr) => {to_unsigned!(i8, to_i8!(i64 , $v))};
430 (i128, $v:expr) => {to_unsigned!(i8, to_i8!(i128, $v))};
431 (u8 , $v:expr) => {to_unsigned!(i8, to_i8!(u8 , $v))};
432 (u16 , $v:expr) => {to_unsigned!(i8, to_i8!(u16 , $v))};
433 (u24 , $v:expr) => {to_unsigned!(i8, to_i8!(u24 , $v))};
434 (u32 , $v:expr) => {to_unsigned!(i8, to_i8!(u32 , $v))};
435 (u64 , $v:expr) => {to_unsigned!(i8, to_i8!(u64 , $v))};
436 (u128, $v:expr) => {to_unsigned!(i8, to_i8!(u128, $v))};
437 (f32 , $v:expr) => {to_unsigned!(i8, to_i8!(f32 , $v))};
438 (f64 , $v:expr) => {to_unsigned!(i8, to_i8!(f64 , $v))};
439}
440
441macro_rules! to_u16 {
442 (i8 , $v:expr) => {to_unsigned!(i16, to_i16!(i8 , $v))};
443 (i16 , $v:expr) => {to_unsigned!(i16, to_i16!(i16 , $v))};
444 (i24 , $v:expr) => {to_unsigned!(i16, to_i16!(i24 , $v))};
445 (i32 , $v:expr) => {to_unsigned!(i16, to_i16!(i32 , $v))};
446 (i64 , $v:expr) => {to_unsigned!(i16, to_i16!(i64 , $v))};
447 (i128, $v:expr) => {to_unsigned!(i16, to_i16!(i128, $v))};
448 (u8 , $v:expr) => {to_unsigned!(i16, to_i16!(u8 , $v))};
449 (u16 , $v:expr) => {to_unsigned!(i16, to_i16!(u16 , $v))};
450 (u24 , $v:expr) => {to_unsigned!(i16, to_i16!(u24 , $v))};
451 (u32 , $v:expr) => {to_unsigned!(i16, to_i16!(u32 , $v))};
452 (u64 , $v:expr) => {to_unsigned!(i16, to_i16!(u64 , $v))};
453 (u128, $v:expr) => {to_unsigned!(i16, to_i16!(u128, $v))};
454 (f32 , $v:expr) => {to_unsigned!(i16, to_i16!(f32 , $v))};
455 (f64 , $v:expr) => {to_unsigned!(i16, to_i16!(f64 , $v))};
456}
457
458macro_rules! to_u24 {
459 (i8 , $v:expr) => {to_unsigned!(i24, to_i24!(i8 , $v))};
460 (i16 , $v:expr) => {to_unsigned!(i24, to_i24!(i16 , $v))};
461 (i24 , $v:expr) => {to_unsigned!(i24, to_i24!(i24 , $v))};
462 (i32 , $v:expr) => {to_unsigned!(i24, to_i24!(i32 , $v))};
463 (i64 , $v:expr) => {to_unsigned!(i24, to_i24!(i64 , $v))};
464 (i128, $v:expr) => {to_unsigned!(i24, to_i24!(i128, $v))};
465 (u8 , $v:expr) => {to_unsigned!(i24, to_i24!(u8 , $v))};
466 (u16 , $v:expr) => {to_unsigned!(i24, to_i24!(u16 , $v))};
467 (u24 , $v:expr) => {to_unsigned!(i24, to_i24!(u24 , $v))};
468 (u32 , $v:expr) => {to_unsigned!(i24, to_i24!(u32 , $v))};
469 (u64 , $v:expr) => {to_unsigned!(i24, to_i24!(u64 , $v))};
470 (u128, $v:expr) => {to_unsigned!(i24, to_i24!(u128, $v))};
471 (f32 , $v:expr) => {to_unsigned!(i24, to_i24!(f32 , $v))};
472 (f64 , $v:expr) => {to_unsigned!(i24, to_i24!(f64 , $v))};
473}
474
475macro_rules! to_u32 {
476 (i8 , $v:expr) => {to_unsigned!(i32, to_i32!(i8 , $v))};
477 (i16 , $v:expr) => {to_unsigned!(i32, to_i32!(i16 , $v))};
478 (i24 , $v:expr) => {to_unsigned!(i32, to_i32!(i24 , $v))};
479 (i32 , $v:expr) => {to_unsigned!(i32, to_i32!(i32 , $v))};
480 (i64 , $v:expr) => {to_unsigned!(i32, to_i32!(i64 , $v))};
481 (i128, $v:expr) => {to_unsigned!(i32, to_i32!(i128, $v))};
482 (u8 , $v:expr) => {to_unsigned!(i32, to_i32!(u8 , $v))};
483 (u16 , $v:expr) => {to_unsigned!(i32, to_i32!(u16 , $v))};
484 (u24 , $v:expr) => {to_unsigned!(i32, to_i32!(u24 , $v))};
485 (u32 , $v:expr) => {to_unsigned!(i32, to_i32!(u32 , $v))};
486 (u64 , $v:expr) => {to_unsigned!(i32, to_i32!(u64 , $v))};
487 (u128, $v:expr) => {to_unsigned!(i32, to_i32!(u128, $v))};
488 (f32 , $v:expr) => {to_unsigned!(i32, to_i32!(f32 , $v))};
489 (f64 , $v:expr) => {to_unsigned!(i32, to_i32!(f64 , $v))};
490}
491
492macro_rules! to_u64 {
493 (i8 , $v:expr) => {to_unsigned!(i64, to_i64!(i8 , $v))};
494 (i16 , $v:expr) => {to_unsigned!(i64, to_i64!(i16 , $v))};
495 (i24 , $v:expr) => {to_unsigned!(i64, to_i64!(i24 , $v))};
496 (i32 , $v:expr) => {to_unsigned!(i64, to_i64!(i32 , $v))};
497 (i64 , $v:expr) => {to_unsigned!(i64, to_i64!(i64 , $v))};
498 (i128, $v:expr) => {to_unsigned!(i64, to_i64!(i128, $v))};
499 (u8 , $v:expr) => {to_unsigned!(i64, to_i64!(u8 , $v))};
500 (u16 , $v:expr) => {to_unsigned!(i64, to_i64!(u16 , $v))};
501 (u24 , $v:expr) => {to_unsigned!(i64, to_i64!(u24 , $v))};
502 (u32 , $v:expr) => {to_unsigned!(i64, to_i64!(u32 , $v))};
503 (u64 , $v:expr) => {to_unsigned!(i64, to_i64!(u64 , $v))};
504 (u128, $v:expr) => {to_unsigned!(i64, to_i64!(u128, $v))};
505 (f32 , $v:expr) => {to_unsigned!(i64, to_i64!(f32 , $v))};
506 (f64 , $v:expr) => {to_unsigned!(i64, to_i64!(f64 , $v))};
507}
508
509macro_rules! to_u128 {
510 (i8 , $v:expr) => {to_unsigned!(i128, to_i128!(i8 , $v))};
511 (i16 , $v:expr) => {to_unsigned!(i128, to_i128!(i16 , $v))};
512 (i24 , $v:expr) => {to_unsigned!(i128, to_i128!(i24 , $v))};
513 (i32 , $v:expr) => {to_unsigned!(i128, to_i128!(i32 , $v))};
514 (i64 , $v:expr) => {to_unsigned!(i128, to_i128!(i64 , $v))};
515 (i128, $v:expr) => {to_unsigned!(i128, to_i128!(i128, $v))};
516 (u8 , $v:expr) => {to_unsigned!(i128, to_i128!(u8 , $v))};
517 (u16 , $v:expr) => {to_unsigned!(i128, to_i128!(u16 , $v))};
518 (u24 , $v:expr) => {to_unsigned!(i128, to_i128!(u24 , $v))};
519 (u32 , $v:expr) => {to_unsigned!(i128, to_i128!(u32 , $v))};
520 (u64 , $v:expr) => {to_unsigned!(i128, to_i128!(u64 , $v))};
521 (u128, $v:expr) => {to_unsigned!(i128, to_i128!(u128, $v))};
522 (f32 , $v:expr) => {to_unsigned!(i128, to_i128!(f32 , $v))};
523 (f64 , $v:expr) => {to_unsigned!(i128, to_i128!(f64 , $v))};
524}
525
526macro_rules! to_f32 {
527 (i8 , $v:expr) => {($v as f32) / (i8 ::MAX) as f32};
528 (i16 , $v:expr) => {($v as f32) / (i16 ::MAX) as f32};
529 (i24 , $v:expr) => {($v.as_i32() as f32) / (0x7FFFFF) as f32};
530 (i32 , $v:expr) => {($v as f32) / (i32 ::MAX) as f32};
531 (i64 , $v:expr) => {($v as f32) / (i64 ::MAX) as f32};
532 (i128, $v:expr) => {($v as f32) / (i128::MAX) as f32};
533 (u8 , $v:expr) => {(to_signed!(u8 , $v) as f32) / (i8 ::MAX) as f32};
534 (u16 , $v:expr) => {(to_signed!(u16 , $v) as f32) / (i16 ::MAX) as f32};
535 (u24 , $v:expr) => {(to_signed!(u24 , $v).as_i32() as f32) / (0x7FFFFF) as f32};
536 (u32 , $v:expr) => {(to_signed!(u32 , $v) as f32) / (i32 ::MAX) as f32};
537 (u64 , $v:expr) => {(to_signed!(u64 , $v) as f32) / (i64 ::MAX) as f32};
538 (u128, $v:expr) => {(to_signed!(u128, $v) as f32) / (i128::MAX) as f32};
539 (f32 , $v:expr) => {$v};
540 (f64 , $v:expr) => {$v as f32};
541}
542
543macro_rules! to_f64 {
544 (i8 , $v:expr) => {($v as f64) / (i8 ::MAX as f64)};
545 (i16 , $v:expr) => {($v as f64) / (i16 ::MAX as f64)};
546 (i24 , $v:expr) => {($v.as_i32() as f64) / (0x7FFFFF as f64)};
547 (i32 , $v:expr) => {($v as f64) / (i32 ::MAX as f64)};
548 (i64 , $v:expr) => {($v as f64) / (i64 ::MAX as f64)};
549 (i128, $v:expr) => {($v as f64) / (i128::MAX as f64)};
550 (u8 , $v:expr) => {(to_signed!(u8 , $v) as f64) / (i8 ::MAX as f64)};
551 (u16 , $v:expr) => {(to_signed!(u16 , $v) as f64) / (i16 ::MAX as f64)};
552 (u24 , $v:expr) => {(to_signed!(u24 , $v).as_i32() as f64) / (0x7FFFFF as f64)};
553 (u32 , $v:expr) => {(to_signed!(u32 , $v) as f64) / (i32 ::MAX as f64)};
554 (u64 , $v:expr) => {(to_signed!(u64 , $v) as f64) / (i64 ::MAX as f64)};
555 (u128, $v:expr) => {(to_signed!(u128, $v) as f64) / (i128::MAX as f64)};
556 (f32 , $v:expr) => {$v as f64};
557 (f64 , $v:expr) => {$v};
558}
559
560macro_rules! to_type {
561 ($st:tt, i8 , $v:expr) => {to_i8!($st, $v)};
562 ($st:tt, i16 , $v:expr) => {to_i16!($st, $v)};
563 ($st:tt, i24 , $v:expr) => {to_i24!($st, $v)};
564 ($st:tt, i32 , $v:expr) => {to_i32!($st, $v)};
565 ($st:tt, i64 , $v:expr) => {to_i64!($st, $v)};
566 ($st:tt, i128, $v:expr) => {to_i128!($st, $v)};
567 ($st:tt, u8 , $v:expr) => {to_u8!($st, $v)};
568 ($st:tt, u16 , $v:expr) => {to_u16!($st, $v)};
569 ($st:tt, u24 , $v:expr) => {to_u24!($st, $v)};
570 ($st:tt, u32 , $v:expr) => {to_u32!($st, $v)};
571 ($st:tt, u64 , $v:expr) => {to_u64!($st, $v)};
572 ($st:tt, u128, $v:expr) => {to_u128!($st, $v)};
573 ($st:tt, f32 , $v:expr) => {to_f32!($st, $v)};
574 ($st:tt, f64 , $v:expr) => {to_f64!($st, $v)};
575}
576
577macro_rules! as_i8 {
578 (i8 , $v:expr) => {$v as i8};
579 (i16 , $v:expr) => {$v as i8};
580 (i24 , $v:expr) => {$v.as_i8()};
581 (i32 , $v:expr) => {$v as i8};
582 (i64 , $v:expr) => {$v as i8};
583 (i128, $v:expr) => {$v as i8};
584 (u8 , $v:expr) => {$v as i8};
585 (u16 , $v:expr) => {$v as i8};
586 (u24 , $v:expr) => {$v.as_i8()};
587 (u32 , $v:expr) => {$v as i8};
588 (u64 , $v:expr) => {$v as i8};
589 (u128, $v:expr) => {$v as i8};
590 (f32 , $v:expr) => {$v as i8};
591 (f64 , $v:expr) => {$v as i8};
592}
593
594macro_rules! as_i16 {
595 (i8 , $v:expr) => {$v as i16};
596 (i16 , $v:expr) => {$v as i16};
597 (i24 , $v:expr) => {$v.as_i16()};
598 (i32 , $v:expr) => {$v as i16};
599 (i64 , $v:expr) => {$v as i16};
600 (i128, $v:expr) => {$v as i16};
601 (u8 , $v:expr) => {$v as i16};
602 (u16 , $v:expr) => {$v as i16};
603 (u24 , $v:expr) => {$v.as_i16()};
604 (u32 , $v:expr) => {$v as i16};
605 (u64 , $v:expr) => {$v as i16};
606 (u128, $v:expr) => {$v as i16};
607 (f32 , $v:expr) => {$v as i16};
608 (f64 , $v:expr) => {$v as i16};
609}
610
611macro_rules! as_i24 {
612 (i8 , $v:expr) => {<i24 as From<i8 >>::from($v)};
613 (i16 , $v:expr) => {<i24 as From<i16 >>::from($v)};
614 (i24 , $v:expr) => {<i24 as From<i24 >>::from($v)};
615 (i32 , $v:expr) => {<i24 as From<i32 >>::from($v)};
616 (i64 , $v:expr) => {<i24 as From<i64 >>::from($v)};
617 (i128, $v:expr) => {<i24 as From<i128>>::from($v)};
618 (u8 , $v:expr) => {<i24 as From<u8 >>::from($v)};
619 (u16 , $v:expr) => {<i24 as From<u16 >>::from($v)};
620 (u24 , $v:expr) => {<i24 as From<u24 >>::from($v)};
621 (u32 , $v:expr) => {<i24 as From<u32 >>::from($v)};
622 (u64 , $v:expr) => {<i24 as From<u64 >>::from($v)};
623 (u128, $v:expr) => {<i24 as From<u128>>::from($v)};
624 (f32 , $v:expr) => {<i24 as From<f32 >>::from($v)};
625 (f64 , $v:expr) => {<i24 as From<f64 >>::from($v)};
626}
627
628macro_rules! as_i32 {
629 (i8 , $v:expr) => {$v as i32};
630 (i16 , $v:expr) => {$v as i32};
631 (i24 , $v:expr) => {$v.as_i32()};
632 (i32 , $v:expr) => {$v as i32};
633 (i64 , $v:expr) => {$v as i32};
634 (i128, $v:expr) => {$v as i32};
635 (u8 , $v:expr) => {$v as i32};
636 (u16 , $v:expr) => {$v as i32};
637 (u24 , $v:expr) => {$v.as_i32()};
638 (u32 , $v:expr) => {$v as i32};
639 (u64 , $v:expr) => {$v as i32};
640 (u128, $v:expr) => {$v as i32};
641 (f32 , $v:expr) => {$v as i32};
642 (f64 , $v:expr) => {$v as i32};
643}
644
645macro_rules! as_i64 {
646 (i8 , $v:expr) => {$v as i64};
647 (i16 , $v:expr) => {$v as i64};
648 (i24 , $v:expr) => {$v.as_i64()};
649 (i32 , $v:expr) => {$v as i64};
650 (i64 , $v:expr) => {$v as i64};
651 (i128, $v:expr) => {$v as i64};
652 (u8 , $v:expr) => {$v as i64};
653 (u16 , $v:expr) => {$v as i64};
654 (u24 , $v:expr) => {$v.as_i64()};
655 (u32 , $v:expr) => {$v as i64};
656 (u64 , $v:expr) => {$v as i64};
657 (u128, $v:expr) => {$v as i64};
658 (f32 , $v:expr) => {$v as i64};
659 (f64 , $v:expr) => {$v as i64};
660}
661
662macro_rules! as_i128 {
663 (i8 , $v:expr) => {$v as i128};
664 (i16 , $v:expr) => {$v as i128};
665 (i24 , $v:expr) => {$v.as_i128()};
666 (i32 , $v:expr) => {$v as i128};
667 (i64 , $v:expr) => {$v as i128};
668 (i128, $v:expr) => {$v as i128};
669 (u8 , $v:expr) => {$v as i128};
670 (u16 , $v:expr) => {$v as i128};
671 (u24 , $v:expr) => {$v.as_i128()};
672 (u32 , $v:expr) => {$v as i128};
673 (u64 , $v:expr) => {$v as i128};
674 (u128, $v:expr) => {$v as i128};
675 (f32 , $v:expr) => {$v as i128};
676 (f64 , $v:expr) => {$v as i128};
677}
678
679macro_rules! as_u8 {
680 (i8 , $v:expr) => {$v as u8};
681 (i16 , $v:expr) => {$v as u8};
682 (i24 , $v:expr) => {$v.as_u8()};
683 (i32 , $v:expr) => {$v as u8};
684 (i64 , $v:expr) => {$v as u8};
685 (i128, $v:expr) => {$v as u8};
686 (u8 , $v:expr) => {$v as u8};
687 (u16 , $v:expr) => {$v as u8};
688 (u24 , $v:expr) => {$v.as_u8()};
689 (u32 , $v:expr) => {$v as u8};
690 (u64 , $v:expr) => {$v as u8};
691 (u128, $v:expr) => {$v as u8};
692 (f32 , $v:expr) => {$v as u8};
693 (f64 , $v:expr) => {$v as u8};
694}
695
696macro_rules! as_u16 {
697 (i8 , $v:expr) => {$v as u16};
698 (i16 , $v:expr) => {$v as u16};
699 (i24 , $v:expr) => {$v.as_u16()};
700 (i32 , $v:expr) => {$v as u16};
701 (i64 , $v:expr) => {$v as u16};
702 (i128, $v:expr) => {$v as u16};
703 (u8 , $v:expr) => {$v as u16};
704 (u16 , $v:expr) => {$v as u16};
705 (u24 , $v:expr) => {$v.as_u16()};
706 (u32 , $v:expr) => {$v as u16};
707 (u64 , $v:expr) => {$v as u16};
708 (u128, $v:expr) => {$v as u16};
709 (f32 , $v:expr) => {$v as u16};
710 (f64 , $v:expr) => {$v as u16};
711}
712
713macro_rules! as_u24 {
714 (i8 , $v:expr) => {<u24 as From<i8 >>::from($v)};
715 (i16 , $v:expr) => {<u24 as From<i16 >>::from($v)};
716 (i24 , $v:expr) => {<u24 as From<i24 >>::from($v)};
717 (i32 , $v:expr) => {<u24 as From<i32 >>::from($v)};
718 (i64 , $v:expr) => {<u24 as From<i64 >>::from($v)};
719 (i128, $v:expr) => {<u24 as From<i128>>::from($v)};
720 (u8 , $v:expr) => {<u24 as From<u8 >>::from($v)};
721 (u16 , $v:expr) => {<u24 as From<u16 >>::from($v)};
722 (u24 , $v:expr) => {<u24 as From<u24 >>::from($v)};
723 (u32 , $v:expr) => {<u24 as From<u32 >>::from($v)};
724 (u64 , $v:expr) => {<u24 as From<u64 >>::from($v)};
725 (u128, $v:expr) => {<u24 as From<u128>>::from($v)};
726 (f32 , $v:expr) => {<u24 as From<f32 >>::from($v)};
727 (f64 , $v:expr) => {<u24 as From<f64 >>::from($v)};
728}
729
730macro_rules! as_u32 {
731 (i8 , $v:expr) => {$v as u32};
732 (i16 , $v:expr) => {$v as u32};
733 (i24 , $v:expr) => {$v.as_u32()};
734 (i32 , $v:expr) => {$v as u32};
735 (i64 , $v:expr) => {$v as u32};
736 (i128, $v:expr) => {$v as u32};
737 (u8 , $v:expr) => {$v as u32};
738 (u16 , $v:expr) => {$v as u32};
739 (u24 , $v:expr) => {$v.as_u32()};
740 (u32 , $v:expr) => {$v as u32};
741 (u64 , $v:expr) => {$v as u32};
742 (u128, $v:expr) => {$v as u32};
743 (f32 , $v:expr) => {$v as u32};
744 (f64 , $v:expr) => {$v as u32};
745}
746
747macro_rules! as_u64 {
748 (i8 , $v:expr) => {$v as u64};
749 (i16 , $v:expr) => {$v as u64};
750 (i24 , $v:expr) => {$v.as_u64()};
751 (i32 , $v:expr) => {$v as u64};
752 (i64 , $v:expr) => {$v as u64};
753 (i128, $v:expr) => {$v as u64};
754 (u8 , $v:expr) => {$v as u64};
755 (u16 , $v:expr) => {$v as u64};
756 (u24 , $v:expr) => {$v.as_u64()};
757 (u32 , $v:expr) => {$v as u64};
758 (u64 , $v:expr) => {$v as u64};
759 (u128, $v:expr) => {$v as u64};
760 (f32 , $v:expr) => {$v as u64};
761 (f64 , $v:expr) => {$v as u64};
762}
763
764macro_rules! as_u128 {
765 (i8 , $v:expr) => {$v as u128};
766 (i16 , $v:expr) => {$v as u128};
767 (i24 , $v:expr) => {$v.as_u128()};
768 (i32 , $v:expr) => {$v as u128};
769 (i64 , $v:expr) => {$v as u128};
770 (i128, $v:expr) => {$v as u128};
771 (u8 , $v:expr) => {$v as u128};
772 (u16 , $v:expr) => {$v as u128};
773 (u24 , $v:expr) => {$v.as_u128()};
774 (u32 , $v:expr) => {$v as u128};
775 (u64 , $v:expr) => {$v as u128};
776 (u128, $v:expr) => {$v as u128};
777 (f32 , $v:expr) => {$v as u128};
778 (f64 , $v:expr) => {$v as u128};
779}
780
781macro_rules! as_f32 {
782 (i8 , $v:expr) => {$v as f32};
783 (i16 , $v:expr) => {$v as f32};
784 (i24 , $v:expr) => {$v.as_f32()};
785 (i32 , $v:expr) => {$v as f32};
786 (i64 , $v:expr) => {$v as f32};
787 (i128, $v:expr) => {$v as f32};
788 (u8 , $v:expr) => {$v as f32};
789 (u16 , $v:expr) => {$v as f32};
790 (u24 , $v:expr) => {$v.as_f32()};
791 (u32 , $v:expr) => {$v as f32};
792 (u64 , $v:expr) => {$v as f32};
793 (u128, $v:expr) => {$v as f32};
794 (f32 , $v:expr) => {$v as f32};
795 (f64 , $v:expr) => {$v as f32};
796}
797
798macro_rules! as_f64 {
799 (i8 , $v:expr) => {$v as f64};
800 (i16 , $v:expr) => {$v as f64};
801 (i24 , $v:expr) => {$v.as_f64()};
802 (i32 , $v:expr) => {$v as f64};
803 (i64 , $v:expr) => {$v as f64};
804 (i128, $v:expr) => {$v as f64};
805 (u8 , $v:expr) => {$v as f64};
806 (u16 , $v:expr) => {$v as f64};
807 (u24 , $v:expr) => {$v.as_f64()};
808 (u32 , $v:expr) => {$v as f64};
809 (u64 , $v:expr) => {$v as f64};
810 (u128, $v:expr) => {$v as f64};
811 (f32 , $v:expr) => {$v as f64};
812 (f64 , $v:expr) => {$v as f64};
813}
814
815macro_rules! average_arr {
816 ($tp:tt, $longer:tt, $arr:expr) => {
817 {
818 type Longer = $longer;
819 let mut sum: Longer = Longer::zero();
820 $arr.iter().for_each(|x|{sum += to_longer!($tp, *x);});
821 to_type!($longer, $tp, sum / to_type!(u64, $longer, $arr.len() as u64))
822 }
823 };
824}
825
826pub trait SampleType: Numeric {
827 type Longer;
828 type Shorter;
829 type Signed;
830 type Unsigned;
831 const MIDNUM: Self;
832 fn new() -> Self;
833 fn zero() -> Self;
834 fn from(v: impl SampleType) -> Self;
835 fn average(s1: Self, s2: Self) -> Self;
836 fn average_arr(arr: &[Self]) -> Self;
837 fn to<T>(&self) -> T where T: SampleType;
838 fn as_<T>(&self) -> T where T: SampleType;
839 fn to_i8 (&self) -> i8 ;
840 fn to_i16(&self) -> i16;
841 fn to_i24(&self) -> i24;
842 fn to_i32(&self) -> i32;
843 fn to_i64(&self) -> i64;
844 fn to_u8 (&self) -> u8 ;
845 fn to_u16(&self) -> u16;
846 fn to_u24(&self) -> u24;
847 fn to_u32(&self) -> u32;
848 fn to_u64(&self) -> u64;
849 fn to_f32(&self) -> f32;
850 fn to_f64(&self) -> f64;
851 fn to_i128(&self) -> i128;
852 fn to_u128(&self) -> u128;
853 fn as_i8 (&self) -> i8 ;
854 fn as_i16(&self) -> i16;
855 fn as_i24(&self) -> i24;
856 fn as_i32(&self) -> i32;
857 fn as_i64(&self) -> i64;
858 fn as_u8 (&self) -> u8 ;
859 fn as_u16(&self) -> u16;
860 fn as_u24(&self) -> u24;
861 fn as_u32(&self) -> u32;
862 fn as_u64(&self) -> u64;
863 fn as_f32(&self) -> f32;
864 fn as_f64(&self) -> f64;
865 fn as_i128(&self) -> i128;
866 fn as_u128(&self) -> u128;
867 fn sizeof(&self) -> usize {size_of::<Self>()}
868 fn to_longer(&self) -> Self::Longer;
869 fn to_shorter(&self) -> Self::Shorter;
870 fn is_signed() -> bool;
871 fn is_unsigned() -> bool;
872 fn is_integer() -> bool;
873 fn is_float() -> bool;
874 fn to_signed(&self) -> Self::Signed;
875 fn to_unsigned(&self) -> Self::Unsigned;
876 fn read_le<T>(r: &mut T) -> Result<Self, Error> where T: Read + ?Sized;
877 fn read_be<T>(r: &mut T) -> Result<Self, Error> where T: Read + ?Sized;
878 fn write_le<T>(&self, w: &mut T) -> Result<(), Error> where T: Write + ?Sized;
879 fn write_be<T>(&self, w: &mut T) -> Result<(), Error> where T: Write + ?Sized;
880}
881
882pub trait SampleFrom: Numeric {
883 fn to(s: impl SampleType) -> Self;
884}
885impl SampleFrom for i8 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_i8() }}
886impl SampleFrom for i16 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_i16() }}
887impl SampleFrom for i24 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_i24() }}
888impl SampleFrom for i32 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_i32() }}
889impl SampleFrom for i64 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_i64() }}
890impl SampleFrom for i128{#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_i128()}}
891impl SampleFrom for u8 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_u8() }}
892impl SampleFrom for u16 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_u16() }}
893impl SampleFrom for u24 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_u24() }}
894impl SampleFrom for u32 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_u32() }}
895impl SampleFrom for u64 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_u64() }}
896impl SampleFrom for u128{#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_u128()}}
897impl SampleFrom for f32 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_f32() }}
898impl SampleFrom for f64 {#[inline(always)] fn to(s: impl SampleType) -> Self { s.to_f64() }}
899
900fn conv<S, T>(v: S) -> T
901where
902 S: SampleType,
903 T: SampleType {
904 T::from(v)
905}
906
907macro_rules! impl_sample_type {
908 ($tp:tt, $longer:tt) => {
909 impl SampleType for $tp {
910 type Longer = longer_type!($tp);
911 type Shorter = shorter_type!($tp);
912 type Signed = signed_type!($tp);
913 type Unsigned = unsigned_type!($tp);
914 const MIDNUM: $tp = mid_number!($tp);
915 #[inline(always)]
916 fn new() -> Self {
917 mid_number!($tp)
918 }
919 #[inline(always)]
920 fn zero() -> Self {
921 zero_number!($tp)
922 }
923 #[inline(always)]
924 fn from(v: impl SampleType) -> Self {
925 v.to::<$tp>()
926 }
927 #[inline(always)]
928 fn average(s1: Self, s2: Self) -> Self {
929 Self::average_arr(&[s1, s2])
930 }
931 #[inline(always)]
932 fn average_arr(arr: &[Self]) -> Self {
933 average_arr!($tp, $longer, arr)
934 }
935 #[inline(always)]
936 fn to<T>(&self) -> T where T: SampleType {
937 match type_name::<T>() {
938 "i8 " => conv(self.to_i8 ()),
939 "i16" => conv(self.to_i16()),
940 "i24" => conv(self.to_i24()),
941 "i32" => conv(self.to_i32()),
942 "i64" => conv(self.to_i64()),
943 "u8 " => conv(self.to_u8 ()),
944 "u16" => conv(self.to_u16()),
945 "u24" => conv(self.to_u24()),
946 "u32" => conv(self.to_u32()),
947 "u64" => conv(self.to_u64()),
948 "f32" => conv(self.to_f32()),
949 "f64" => conv(self.to_f64()),
950 "i128" => conv(self.to_i128()),
951 "u128" => conv(self.to_u128()),
952 o => panic!("Unknown type name: {o}"),
953 }
954 }
955 #[inline(always)]
956 fn as_<T>(&self) -> T where T: SampleType {
957 match type_name::<T>() {
958 "i8 " => conv(self.as_i8 ()),
959 "i16" => conv(self.as_i16()),
960 "i24" => conv(self.as_i24()),
961 "i32" => conv(self.as_i32()),
962 "i64" => conv(self.as_i64()),
963 "u8 " => conv(self.as_u8 ()),
964 "u16" => conv(self.as_u16()),
965 "u24" => conv(self.as_u24()),
966 "u32" => conv(self.as_u32()),
967 "u64" => conv(self.as_u64()),
968 "f32" => conv(self.as_f32()),
969 "f64" => conv(self.as_f64()),
970 "i128" => conv(self.as_i128()),
971 "u128" => conv(self.as_u128()),
972 o => panic!("Unknown type name: {o}"),
973 }
974 }
975 #[inline(always)]fn to_i8 (&self) -> i8 {to_i8! ($tp, *self)}
976 #[inline(always)]fn to_i16(&self) -> i16 {to_i16!($tp, *self)}
977 #[inline(always)]fn to_i24(&self) -> i24 {to_i24!($tp, *self)}
978 #[inline(always)]fn to_i32(&self) -> i32 {to_i32!($tp, *self)}
979 #[inline(always)]fn to_i64(&self) -> i64 {to_i64!($tp, *self)}
980 #[inline(always)]fn to_u8 (&self) -> u8 {to_u8! ($tp, *self)}
981 #[inline(always)]fn to_u16(&self) -> u16 {to_u16!($tp, *self)}
982 #[inline(always)]fn to_u24(&self) -> u24 {to_u24!($tp, *self)}
983 #[inline(always)]fn to_u32(&self) -> u32 {to_u32!($tp, *self)}
984 #[inline(always)]fn to_u64(&self) -> u64 {to_u64!($tp, *self)}
985 #[inline(always)]fn to_f32(&self) -> f32 {to_f32!($tp, *self)}
986 #[inline(always)]fn to_f64(&self) -> f64 {to_f64!($tp, *self)}
987 #[inline(always)]fn to_i128(&self) -> i128 {to_i128!($tp, *self)}
988 #[inline(always)]fn to_u128(&self) -> u128 {to_u128!($tp, *self)}
989 #[inline(always)]fn as_i8 (&self) -> i8 {as_i8! ($tp, *self)}
990 #[inline(always)]fn as_i16(&self) -> i16 {as_i16!($tp, *self)}
991 #[inline(always)]fn as_i24(&self) -> i24 {as_i24!($tp, *self)}
992 #[inline(always)]fn as_i32(&self) -> i32 {as_i32!($tp, *self)}
993 #[inline(always)]fn as_i64(&self) -> i64 {as_i64!($tp, *self)}
994 #[inline(always)]fn as_u8 (&self) -> u8 {as_u8! ($tp, *self)}
995 #[inline(always)]fn as_u16(&self) -> u16 {as_u16!($tp, *self)}
996 #[inline(always)]fn as_u24(&self) -> u24 {as_u24!($tp, *self)}
997 #[inline(always)]fn as_u32(&self) -> u32 {as_u32!($tp, *self)}
998 #[inline(always)]fn as_u64(&self) -> u64 {as_u64!($tp, *self)}
999 #[inline(always)]fn as_f32(&self) -> f32 {as_f32!($tp, *self)}
1000 #[inline(always)]fn as_f64(&self) -> f64 {as_f64!($tp, *self)}
1001 #[inline(always)]fn as_i128(&self) -> i128 {as_i128!($tp, *self)}
1002 #[inline(always)]fn as_u128(&self) -> u128 {as_u128!($tp, *self)}
1003 #[inline(always)]
1004 fn to_longer(&self) -> Self::Longer {
1005 to_longer!($tp, *self)
1006 }
1007 #[inline(always)]
1008 fn to_shorter(&self) -> Self::Shorter {
1009 to_shorter!($tp, *self)
1010 }
1011 #[inline(always)]
1012 fn is_signed() -> bool {
1013 is_signed!($tp)
1014 }
1015 #[inline(always)]
1016 fn is_unsigned() -> bool {
1017 is_unsigned!($tp)
1018 }
1019 #[inline(always)]
1020 fn is_integer() -> bool {
1021 is_integer!($tp)
1022 }
1023 #[inline(always)]
1024 fn is_float() -> bool {
1025 is_float!($tp)
1026 }
1027 #[inline(always)]
1028 fn to_signed(&self) -> Self::Signed {
1029 to_signed!($tp, *self)
1030 }
1031 #[inline(always)]
1032 fn to_unsigned(&self) -> Self::Unsigned {
1033 to_unsigned!($tp, *self)
1034 }
1035 #[inline(always)]
1036 fn read_le<T>(r: &mut T) -> Result<Self, Error>
1037 where T: Read + ?Sized {
1038 let mut buf = [0u8; sizeof!($tp)];
1039 r.read_exact(&mut buf)?;
1040 Ok(Self::from_le_bytes(buf))
1041 }
1042 #[inline(always)]
1043 fn read_be<T>(r: &mut T) -> Result<Self, Error>
1044 where T: Read + ?Sized {
1045 let mut buf = [0u8; sizeof!($tp)];
1046 r.read_exact(&mut buf)?;
1047 Ok(Self::from_be_bytes(buf))
1048 }
1049 #[inline(always)]
1050 fn write_le<T>(&self, w: &mut T) -> Result<(), Error>
1051 where T: Write + ?Sized {
1052 w.write_all(&self.to_le_bytes())
1053 }
1054 #[inline(always)]
1055 fn write_be<T>(&self, w: &mut T) -> Result<(), Error>
1056 where T: Write + ?Sized {
1057 w.write_all(&self.to_be_bytes())
1058 }
1059 }
1060 }
1061}
1062
1063impl_sample_type!(i8 , i16 );
1064impl_sample_type!(i16 , i24 );
1065impl_sample_type!(i24 , i32 );
1066impl_sample_type!(i32 , i64 );
1067impl_sample_type!(i64 , i128);
1068impl_sample_type!(i128, i128);
1069impl_sample_type!(u8 , u16 );
1070impl_sample_type!(u16 , u24 );
1071impl_sample_type!(u24 , u32 );
1072impl_sample_type!(u32 , u64 );
1073impl_sample_type!(u64 , u128);
1074impl_sample_type!(u128, u128);
1075impl_sample_type!(f32 , f64 );
1076impl_sample_type!(f64 , f64 );
1077