Debian Codegraph @

.cargo/vendor/rustdct/src/common.rs

raw
1 use rustfft::num_traits::FloatConst;
2 use rustfft::FftNum;
3
4 /// Generic floating point number
5 pub trait DctNum: FftNum + FloatConst {
6 fn half() -> Self;
7 fn two() -> Self;
8 }
9
10 impl<T: FftNum + FloatConst> DctNum for T {
11 fn half() -> Self {
12 Self::from_f64(0.5).unwrap()
13 }
14 fn two() -> Self {
15 Self::from_f64(2.0).unwrap()
16 }
17 }
18
19 // Validates the given buffer verifying that it has the correct length.
20 macro_rules! validate_buffer {
21 ($buffer: expr,$expected_buffer_len: expr) => {{
22 if $buffer.len() != $expected_buffer_len {
23 dct_error_inplace($buffer.len(), 0, $expected_buffer_len, 0);
24 return;
25 }
26 }};
27 }
28
29 // Validates the given buffer and scratch by verifying that they have the correct length. Then, slices the scratch down to just the required amount
30 macro_rules! validate_buffers {
31 ($buffer: expr, $scratch: expr, $expected_buffer_len: expr, $expected_scratch_len: expr) => {{
32 if $buffer.len() != $expected_buffer_len {
33 dct_error_inplace(
34 $buffer.len(),
35 $scratch.len(),
36 $expected_buffer_len,
37 $expected_scratch_len,
38 );
39 return;
40 }
41 if let Some(sliced_scratch) = $scratch.get_mut(0..$expected_scratch_len) {
42 sliced_scratch
43 } else {
44 dct_error_inplace(
45 $buffer.len(),
46 $scratch.len(),
47 $expected_buffer_len,
48 $expected_scratch_len,
49 );
50 return;
51 }
52 }};
53 }
54
55 // Validates the given buffer and scratch by verifying that they have the correct length. Then, slices the scratch down to just the required amount
56 macro_rules! validate_buffers_mdct {
57 ($buffer_a: expr, $buffer_b: expr, $buffer_c: expr, $scratch: expr, $expected_buffer_len: expr, $expected_scratch_len: expr) => {{
58 if $buffer_a.len() != $expected_buffer_len
59 || $buffer_b.len() != $expected_buffer_len
60 || $buffer_c.len() != $expected_buffer_len
61 {
62 mdct_error_inplace(
63 $buffer_a.len(),
64 $buffer_b.len(),
65 $buffer_c.len(),
66 $scratch.len(),
67 $expected_buffer_len,
68 $expected_scratch_len,
69 );
70 return;
71 }
72 if let Some(sliced_scratch) = $scratch.get_mut(0..$expected_scratch_len) {
73 sliced_scratch
74 } else {
75 mdct_error_inplace(
76 $buffer_a.len(),
77 $buffer_b.len(),
78 $buffer_c.len(),
79 $scratch.len(),
80 $expected_buffer_len,
81 $expected_scratch_len,
82 );
83 return;
84 }
85 }};
86 }
87
88 // Prints an error raised by an in-place FFT algorithm's `process_inplace` method
89 // Marked cold and inline never to keep all formatting code out of the many monomorphized process_inplace methods
90 #[cold]
91 #[inline(never)]
92 pub fn dct_error_inplace(
93 actual_len: usize,
94 actual_scratch: usize,
95 expected_len: usize,
96 expected_scratch: usize,
97 ) {
98 assert!(
99 actual_len == expected_len,
100 "Provided buffer must be equal to the transform size. Expected len = {}, got len = {}",
101 expected_len,
102 actual_len
103 );
104 assert!(
105 actual_scratch >= expected_scratch,
106 "Not enough scratch space was provided. Expected scratch len >= {}, got scratch len = {}",
107 expected_scratch,
108 actual_scratch
109 );
110 }
111
112 // Prints an error raised by an in-place FFT algorithm's `process_inplace` method
113 // Marked cold and inline never to keep all formatting code out of the many monomorphized process_inplace methods
114 #[cold]
115 #[inline(never)]
116 pub fn mdct_error_inplace(
117 actual_len_a: usize,
118 actual_len_b: usize,
119 actual_len_c: usize,
120 actual_scratch: usize,
121 expected_len: usize,
122 expected_scratch: usize,
123 ) {
124 assert!(
125 actual_len_a == expected_len,
126 "All three MDCT buffers must be equal to the transform size. Expected len = {}, but first buffer was len = {}",
127 expected_len,
128 actual_len_a
129 );
130 assert!(
131 actual_len_b == expected_len,
132 "All three MDCT buffers must be equal to the transform size. Expected len = {}, but second buffer was len = {}",
133 expected_len,
134 actual_len_b
135 );
136 assert!(
137 actual_len_c == expected_len,
138 "All three MDCT buffers must be equal to the transform size. Expected len = {}, but third buffer was len = {}",
139 expected_len,
140 actual_len_c
141 );
142 assert!(
143 actual_scratch >= expected_scratch,
144 "Not enough scratch space was provided. Expected scratch len >= {}, got scratch len = {}",
145 expected_scratch,
146 actual_scratch
147 );
148 }