2 #ifndef __BSE_BLOCK_UTILS_H__
3 #define __BSE_BLOCK_UTILS_H__
8 template<
class TYPE>
inline
9 void bse_block_fill_0 (
size_t n_values,
14 char* bse_block_impl_name (
void);
16 void bse_block_fill_uint32 (guint n_values,
20 void bse_block_fill_float (uint n_values,
24 void bse_block_copy_uint32 (guint n_values,
26 const guint32 *ivalues);
28 void bse_block_copy_float (guint n_values,
30 const gfloat *ivalues);
31 void bse_block_add_floats (guint n_values,
33 const float *ivalues);
34 void bse_block_sub_floats (guint n_values,
36 const float *ivalues);
37 void bse_block_mul_floats (guint n_values,
39 const float *ivalues);
40 void bse_block_scale_floats (guint n_values,
44 void bse_block_interleave2_floats (guint n_ivalues,
48 void bse_block_interleave2_add_floats (guint n_ivalues,
52 void bse_block_calc_float_range (guint n_values,
56 float bse_block_calc_float_square_sum (guint n_values,
57 const float *ivalues);
58 float bse_block_calc_float_range_and_square_sum (guint n_values,
72 static const char* impl_name () {
return singleton->impl_name (); }
73 static inline void fill (guint n_values,
76 static inline void fill (guint n_values,
79 static inline void copy (guint n_values,
81 const float *ivalues);
82 static inline void copy (guint n_values,
84 const guint32 *ivalues);
85 static inline void add (guint n_values,
87 const float *ivalues) { singleton->add (n_values, ovalues, ivalues); }
88 static inline void sub (guint n_values,
90 const float *ivalues) { singleton->sub (n_values, ovalues, ivalues); }
91 static inline void mul (guint n_values,
93 const float *ivalues) { singleton->mul (n_values, ovalues, ivalues); }
94 static inline void scale (guint n_values,
97 const float level) { singleton->scale (n_values, ovalues, ivalues, level); }
98 static inline void interleave2 (guint n_ivalues,
100 const float *ivalues,
101 guint offset) { singleton->interleave2 (n_ivalues, ovalues, ivalues, offset); }
102 static inline void interleave2_add (guint n_ivalues,
104 const float *ivalues,
105 guint offset) { singleton->interleave2_add (n_ivalues, ovalues, ivalues, offset); }
106 static inline void range (guint n_values,
107 const float *ivalues,
109 float& max_value) { singleton->range (n_values, ivalues, min_value, max_value); }
110 static inline float square_sum (guint n_values,
111 const float *ivalues) {
return singleton->square_sum (n_values, ivalues); }
112 static inline float range_and_square_sum (guint n_values,
113 const float *ivalues,
115 float& max_value) {
return singleton->range_and_square_sum (n_values, ivalues, min_value, max_value); }
117 typedef Resampler::Resampler2 Resampler2;
119 Resampler2* create_resampler2 (BseResampler2Mode mode,
120 BseResampler2Precision precision) {
return singleton->create_resampler2 (mode, precision); }
122 bool test_resampler2 (
bool verbose) {
return singleton->test_resampler2 (verbose); }
129 virtual const char* impl_name () = 0;
130 virtual void add (guint n_values,
132 const float *ivalues) = 0;
133 virtual void sub (guint n_values,
135 const float *ivalues) = 0;
136 virtual void mul (guint n_values,
138 const float *ivalues) = 0;
139 virtual void scale (guint n_values,
141 const float *ivalues,
142 const float level) = 0;
143 virtual void interleave2 (guint n_ivalues,
145 const float *ivalues,
147 virtual void interleave2_add (guint n_ivalues,
149 const float *ivalues,
151 virtual void range (guint n_values,
152 const float *ivalues,
154 float& max_value) = 0;
155 virtual float square_sum (guint n_values,
156 const float *ivalues) = 0;
157 virtual float range_and_square_sum (guint n_values,
158 const float *ivalues,
160 float& max_value) = 0;
162 Resampler2* create_resampler2 (BseResampler2Mode mode,
163 BseResampler2Precision precision) = 0;
164 virtual bool test_resampler2 (
bool verbose) = 0;
166 static void substitute (Impl *substitute_impl);
168 static Impl* default_singleton ();
169 static Impl* current_singleton ();
171 static Impl *singleton;
176 Block::fill (guint n_values,
180 RAPICORN_STATIC_ASSERT (
sizeof (
float) == 4);
181 RAPICORN_STATIC_ASSERT (
sizeof (
wchar_t) == 4);
182 const union {
float f; guint32 vuint32; } u = { value };
183 wmemset ((
wchar_t*) values, u.vuint32, n_values);
187 Block::fill (guint n_values,
191 RAPICORN_STATIC_ASSERT (
sizeof (
wchar_t) == 4);
192 wmemset ((
wchar_t*) values, value, n_values);
196 Block::copy (guint n_values,
198 const guint32 *ivalues)
200 RAPICORN_STATIC_ASSERT (
sizeof (
wchar_t) == 4);
201 wmemcpy ((
wchar_t*) values, (
const wchar_t*) ivalues, n_values);
205 Block::copy (guint n_values,
207 const gfloat *ivalues)
209 RAPICORN_STATIC_ASSERT (
sizeof (
float) == 4);
210 RAPICORN_STATIC_ASSERT (
sizeof (
wchar_t) == 4);
211 wmemcpy ((
wchar_t*) values, (
const wchar_t*) ivalues, n_values);
221 bse_block_fill_uint32 (guint n_values,
225 RAPICORN_STATIC_ASSERT (
sizeof (
wchar_t) == 4);
226 wmemset ((
wchar_t*) values, vuint32, n_values);
230 bse_block_fill_float (guint n_values,
234 RAPICORN_STATIC_ASSERT (
sizeof (
float) == 4);
235 const union {
float f; guint32 vuint32; } u = { value };
236 RAPICORN_STATIC_ASSERT (
sizeof (
wchar_t) == 4);
237 wmemset ((
wchar_t*) values, u.vuint32, n_values);
241 bse_block_copy_uint32 (guint n_values,
243 const guint32 *ivalues)
245 RAPICORN_STATIC_ASSERT (
sizeof (
wchar_t) == 4);
246 wmemcpy ((
wchar_t*) values, (
const wchar_t*) ivalues, n_values);
250 bse_block_copy_float (guint n_values,
252 const gfloat *ivalues)
254 RAPICORN_STATIC_ASSERT (
sizeof (
float) == 4);
255 RAPICORN_STATIC_ASSERT (
sizeof (
wchar_t) == 4);
256 wmemcpy ((
wchar_t*) values, (
const wchar_t*) ivalues, n_values);
261 template<
class TYPE>
inline void
262 bse_block_fill_0 (
size_t n_values, TYPE *values)
264 size_t n_bytes = n_values *
sizeof (TYPE);
265 char *p = (
char*) values;
267 if (RAPICORN_UNLIKELY (r))
269 r = MIN (r, n_values);
274 const size_t n_aligned = n_bytes / 4;
275 wmemset ((
wchar_t*) p, 0, n_aligned);
276 n_bytes -= n_aligned * 4;
277 if (RAPICORN_UNLIKELY (n_bytes))