Debian Codegraph @

modules/lsp-runtime-lib/src/main/mm/sample.cpp

raw
1 /*
2 * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2025 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 16 апр. 2020 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/common/endian.h>
23 #include <lsp-plug.in/mm/sample.h>
24 #include <lsp-plug.in/stdlib/string.h>
25
26 /*
27 * TODO: fix floating-point rounding
28 *
29 * https://www.cs.cmu.edu/~rbd/papers/cmj-float-to-int.html
30 *
31 * Most audio programs convert floating point samples to integer samples and write
32 * them to a file or an audio output device. I will assume that ‘‘correct’’ behavior
33 * is to round to the nearest integer value. Dealing with scale factors and overflow
34 * are also important issues, but there is no standard and the best approach may depend
35 * on the application. I will limit my discussion to rounding, which is where this bug occurs.
36 *
37 * The natural way to implement the conversion is to scale each floating point sample
38 * to some appropriate range (-32767 to 32767) and assign it to a signed 16-bit integer as follows:
39 * float f; // assume -32768 <= f <= 32767
40 * int i; // could also be “shortint”
41 * i = (int) f; // “(int) f” means “convert f to an int”
42 *
43 * The default float-to-integer conversion in C does not round to the nearest integer,
44 * but instead truncates toward zero. That means that signal values in the open interval (–1.0, 1.0)
45 * are all converted to zero (0). This interval is twice as large as the interval mapping to any other
46 * integer, and this introduces a nonlinear distortion into the signal. This is not just an issue of
47 * truncation versus rounding. It is well known that rounding to the nearest integer can be achieved by adding 0.5
48 * and rounding down, but the following C assignment is incorrect:
49 *
50 * i = (int)(f + 0.5);
51 *
52 * C does not round negative numbers down, so values in the interval (-1.5, 0.5) are converted to zero.
53 * In contrast, a correct conversion should map only the interval (-0.5, 0.5) to zero.
54 * There are several ways to perform rounding for audio, and, surprisingly, proper rounding can be faster
55 * than the default conversion in C. The direct implementation is to treat positive and negative numbers as
56 * different cases:
57 *
58 * float f; // assume -32768 <= f <= 32767
59 * int i; // could also be “shortint”
60 * if(f > 0) { i = (int)(f + 0.5); }
61 * else { i = (int)(f - 0.5); }
62 *
63 * This code has the problem of taking a branch, which is very slow relative to arithmetic on modern
64 * processors. However, this is a good approach if you can combine the rounding with testing for peak
65 * values and clipping out-ofrange values, which also treat positive and negative samples separately.
66 * An elegant approach, suggested by Phil Burk, the developer of JSyn and co-developer of PortAudio,
67 * is to offset the sample values to make them all positive, perform rounding, and then shift back.
68 * Note that I add an extra 0.5 before truncating to simulate rounding behavior:
69 *
70 * i = (((int) (f + 32768.5)) - 32768)
71 *
72 */
73
74 namespace lsp
75 {
76 namespace mm
77 {
78 typedef void (*cvt_sample_t) (void *dst, const void *src, size_t samples);
79
80 static inline uint32_t read24bit(const uint8_t *p)
81 {
82 uint32_t res =
83 __IF_LEBE(
84 (uint32_t(p[0])) | (uint32_t(p[1]) << 8) | (uint32_t(p[2]) << 16),
85 (uint32_t(p[2])) | (uint32_t(p[1]) << 8) | (uint32_t(p[0]) << 16)
86 );
87 return res;
88 }
89
90 static inline void write24bit(uint8_t *p, uint32_t x)
91 {
92 __IF_LE(
93 p[0] = uint8_t(x);
94 p[1] = uint8_t(x >> 8);
95 p[2] = uint8_t(x >> 16);
96 )
97 __IF_BE(
98 p[0] = uint8_t(x >> 16);
99 p[1] = uint8_t(x >> 8);
100 p[2] = uint8_t(x);
101 )
102 }
103
104 bool sample_endian_swap(void *buf, size_t samples, size_t format)
105 {
106 size_t fmt = sformat_endian(format);
107 if (fmt == __IF_LEBE(SFMT_LE, SFMT_BE))
108 return true;
109 else if (fmt != __IF_LEBE(SFMT_BE, SFMT_LE))
110 return false;
111
112 switch (sformat_format(format))
113 {
114 case SFMT_U8:
115 case SFMT_S8:
116 break;
117 case SFMT_U16:
118 case SFMT_S16:
119 ::lsp::byte_swap(static_cast<uint16_t *>(buf), samples);
120 break;
121 case SFMT_U32:
122 case SFMT_S32:
123 ::lsp::byte_swap(static_cast<uint32_t *>(buf), samples);
124 break;
125 case SFMT_F32:
126 ::lsp::byte_swap(static_cast<f32_t *>(buf), samples);
127 break;
128 case SFMT_F64:
129 ::lsp::byte_swap(static_cast<f64_t *>(buf), samples);
130 break;
131
132 case SFMT_U24: case SFMT_S24:
133 {
134 uint8_t x, *ptr = static_cast<uint8_t *>(buf);
135 while (samples--)
136 {
137 x = ptr[0];
138 ptr[0] = ptr[2];
139 ptr[2] = x;
140 ptr += 3;
141 }
142 break;
143 }
144
145 default:
146 return false;
147 }
148
149 return true;
150 }
151
152 #define CVT_SHIFT(TYPE) (uint32_t(1 << (sizeof(TYPE)*8 - 1)))
153 #define CVT_RANGE(TYPE) (uint32_t(1 << (sizeof(TYPE)*8 - 1))-1)
154
155 // Integer conversions
156 #define CVT_UI_TO_UI(DTYPE, STYPE, SHIFT) \
157 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, ++dptr) \
158 *dptr = (DTYPE)((*sptr) SHIFT);
159
160 #define CVT_UI_TO_SI(DTYPE, STYPE, SHIFT) \
161 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, ++dptr) \
162 *dptr = (DTYPE)((*sptr - CVT_SHIFT(STYPE)) SHIFT);
163
164 #define CVT_SI_TO_UI(DTYPE, STYPE, SHIFT) \
165 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, ++dptr) \
166 *dptr = (DTYPE)((*sptr + CVT_SHIFT(STYPE)) SHIFT);
167
168 #define CVT_SI_TO_SI(DTYPE, STYPE, SHIFT) \
169 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, ++dptr) \
170 *dptr = (DTYPE)((*sptr) SHIFT);
171
172 #define CVT_UI_TO_FX(DTYPE, STYPE) \
173 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, ++dptr) \
174 *dptr = ((STYPE)(*sptr - CVT_SHIFT(STYPE))) * (DTYPE(1.0 / CVT_RANGE(STYPE)));
175
176 #define CVT_SI_TO_FX(DTYPE, STYPE) \
177 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, ++dptr) \
178 *dptr = ((STYPE)(*sptr)) * (DTYPE(1.0 / CVT_RANGE(STYPE)));
179
180 #define CVT_UI_TO_XI(DTYPE, STYPE, SHIFT) \
181 if (sign) \
182 CVT_UI_TO_SI(DTYPE, STYPE, SHIFT) \
183 else \
184 CVT_UI_TO_UI(DTYPE, STYPE, SHIFT)
185
186 #define CVT_SI_TO_XI(DTYPE, STYPE, SHIFT) \
187 if (sign) \
188 CVT_SI_TO_SI(DTYPE, STYPE, SHIFT) \
189 else \
190 CVT_SI_TO_UI(DTYPE, STYPE, SHIFT)
191
192 // Integer 24-bit conversions
193 #define CVT_U24_TO_UI(DTYPE, SHIFT) \
194 for (uint8_t *sptr = static_cast<uint8_t *>(src); samples > 0; --samples, sptr += 3, ++dptr) \
195 *dptr = (DTYPE)(read24bit(sptr) SHIFT);
196
197 #define CVT_U24_TO_SI(DTYPE, SHIFT) \
198 for (uint8_t *sptr = static_cast<uint8_t *>(src); samples > 0; --samples, sptr += 3, ++dptr) \
199 *dptr = (DTYPE)((read24bit(sptr) - 0x800000) SHIFT);
200
201 #define CVT_S24_TO_UI(DTYPE, SHIFT) \
202 for (uint8_t *sptr = static_cast<uint8_t *>(src); samples > 0; --samples, sptr += 3, ++dptr) \
203 *dptr = (DTYPE)((read24bit(sptr) + 0x800000) SHIFT);
204
205 #define CVT_S24_TO_SI(DTYPE, SHIFT) \
206 for (uint8_t *sptr = static_cast<uint8_t *>(src); samples > 0; --samples, sptr += 3, ++dptr) \
207 *dptr = (DTYPE)(read24bit(sptr) SHIFT);
208
209 #define CVT_U24_TO_FX(DTYPE) \
210 for (uint8_t *sptr = static_cast<uint8_t *>(src); samples > 0; --samples, sptr += 3, ++dptr) \
211 *dptr = (int32_t(read24bit(sptr) - 0x800000) * (DTYPE(1.0)/0x7fffff));
212
213 #define CVT_S24_TO_FX(DTYPE) \
214 for (uint8_t *sptr = static_cast<uint8_t *>(src); samples > 0; --samples, sptr += 3, ++dptr) \
215 *dptr = ((int32_t(read24bit(sptr) << 8) >> 8) * (DTYPE(1.0)/0x7fffff));
216
217 #define CVT_U24_TO_XI(DTYPE, SHIFT) \
218 if (sign) \
219 CVT_U24_TO_SI(DTYPE, SHIFT) \
220 else \
221 CVT_U24_TO_UI(DTYPE, SHIFT)
222
223 #define CVT_S24_TO_XI(DTYPE, SHIFT) \
224 if (sign) \
225 CVT_S24_TO_SI(DTYPE, SHIFT) \
226 else \
227 CVT_S24_TO_UI(DTYPE, SHIFT)
228
229
230 #define CVT_UI_TO_UI24(STYPE, SHIFT) \
231 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, dptr += 3) \
232 write24bit(dptr, uint32_t((*sptr) SHIFT));
233
234 #define CVT_UI_TO_SI24(STYPE, SHIFT) \
235 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, dptr += 3) \
236 write24bit(dptr, uint32_t((*sptr - CVT_SHIFT(STYPE)) SHIFT));
237
238 #define CVT_SI_TO_UI24(STYPE, SHIFT) \
239 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, dptr += 3) \
240 write24bit(dptr, uint32_t((*sptr + CVT_SHIFT(STYPE)) SHIFT));
241
242 #define CVT_SI_TO_SI24(STYPE, SHIFT) \
243 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, dptr += 3) \
244 write24bit(dptr, uint32_t((*sptr) SHIFT));
245
246 #define CVT_UI_TO_XI24(STYPE, SHIFT) \
247 if (sign) \
248 CVT_UI_TO_SI24(STYPE, SHIFT) \
249 else \
250 CVT_UI_TO_UI24(STYPE, SHIFT)
251
252 #define CVT_SI_TO_XI24(STYPE, SHIFT) \
253 if (sign) \
254 CVT_SI_TO_SI24(STYPE, SHIFT) \
255 else \
256 CVT_SI_TO_UI24(STYPE, SHIFT)
257
258 #define CVT_SI24_TO_UI24() \
259 for (uint8_t *sptr = static_cast<uint8_t *>(src); samples > 0; --samples, sptr += 3, dptr += 3) \
260 write24bit(dptr, read24bit(sptr) + 0x800000);
261
262 #define CVT_UI24_TO_SI24() \
263 for (uint8_t *sptr = static_cast<uint8_t *>(src); samples > 0; --samples, sptr += 3, dptr += 3) \
264 write24bit(dptr, read24bit(sptr) - 0x800000);
265
266 // Float conversions
267 #define CVT_F32_TO_UI(STYPE, DTYPE) \
268 for (f32_t *sptr = static_cast<f32_t *>(src); samples > 0; --samples, ++sptr, ++dptr) \
269 *dptr = (STYPE)(*sptr * f32_t(CVT_RANGE(DTYPE))) + (DTYPE)CVT_SHIFT(DTYPE);
270 #define CVT_F32_TO_SI(DTYPE) \
271 for (f32_t *sptr = static_cast<f32_t *>(src); samples > 0; --samples, ++sptr, ++dptr) \
272 *dptr = (DTYPE)(*sptr * f32_t(CVT_RANGE(DTYPE)));
273
274 #define CVT_F32_TO_XI(STYPE, DTYPE) \
275 if (sign) \
276 CVT_F32_TO_SI(STYPE) \
277 else \
278 CVT_F32_TO_UI(STYPE, DTYPE)
279
280
281 // Double conversions
282 #define CVT_F64_TO_UI(STYPE, DTYPE) \
283 for (f64_t *sptr = static_cast<f64_t *>(src); samples > 0; --samples, ++sptr, ++dptr) \
284 *dptr = (STYPE)(*sptr * f64_t(CVT_RANGE(DTYPE))) + (DTYPE)CVT_SHIFT(DTYPE);
285 #define CVT_F64_TO_SI(DTYPE) \
286 for (f64_t *sptr = static_cast<f64_t *>(src); samples > 0; --samples, ++sptr, ++dptr) \
287 *dptr = (DTYPE)(*sptr * f64_t(CVT_RANGE(DTYPE)));
288
289 #define CVT_F64_TO_XI(STYPE, DTYPE) \
290 if (sign) \
291 CVT_F64_TO_SI(STYPE) \
292 else \
293 CVT_F64_TO_UI(STYPE, DTYPE)
294
295 // Floating-point conversions
296 #define CVT_FX_TO_SI24(STYPE) \
297 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, dptr += 3) \
298 write24bit(dptr, int32_t(*sptr * 0x7fffff));
299 #define CVT_FX_TO_UI24(STYPE) \
300 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, dptr += 3) \
301 write24bit(dptr, int32_t(*sptr * 0x7fffff) - 0x800000);
302 #define CVT_FX_TO_XI24(STYPE) \
303 if (sign) \
304 CVT_FX_TO_SI24(STYPE) \
305 else \
306 CVT_FX_TO_UI24(STYPE)
307
308 #define CVT_FX_TO_UI32(STYPE) \
309 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, ++dptr) \
310 *dptr = (int32_t)(*sptr * f64_t(CVT_RANGE(uint32_t))) + (uint32_t)CVT_SHIFT(uint32_t);
311 #define CVT_FX_TO_SI32(STYPE) \
312 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, ++dptr) \
313 *dptr = (int32_t)(*sptr * f64_t(CVT_RANGE(uint32_t)));
314
315 #define CVT_FX_TO_XI32(STYPE) \
316 if (sign) \
317 CVT_FX_TO_SI32(STYPE) \
318 else \
319 CVT_FX_TO_UI32(STYPE)
320
321 #define CVT_FX_TO_FX(DTYPE, STYPE) \
322 for (STYPE *sptr = static_cast<STYPE *>(src); samples > 0; --samples, ++sptr, ++dptr) \
323 *dptr = (DTYPE)(*sptr);
324
325
326 bool convert_to_8bit(void *dst, void *src, size_t samples, size_t to, size_t from)
327 {
328 int sign = sformat_sign(to);
329 if (sign < 0)
330 return false;
331 uint8_t *dptr = static_cast<uint8_t *>(dst);
332
333 switch (sformat_format(from))
334 {
335 case SFMT_U8:
336 if (sign) CVT_UI_TO_SI(uint8_t, uint8_t, )
337 else ::memcpy(dptr, src, samples * sizeof(uint8_t));
338 return true;
339 case SFMT_S8:
340 if (sign) ::memcpy(dptr, src, samples * sizeof(uint8_t));
341 else CVT_SI_TO_UI(uint8_t, uint8_t, )
342 return true;
343
344 case SFMT_U16: CVT_UI_TO_XI(uint8_t, uint16_t, >> 8) return true;
345 case SFMT_S16: CVT_SI_TO_XI(uint8_t, uint16_t, >> 8) return true;
346 case SFMT_U24: CVT_U24_TO_XI(uint8_t, >> 16) return true;
347 case SFMT_S24: CVT_S24_TO_XI(uint8_t, >> 16) return true;
348 case SFMT_U32: CVT_UI_TO_XI(uint8_t, uint32_t, >> 24) return true;
349 case SFMT_S32: CVT_SI_TO_XI(uint8_t, uint32_t, >> 24) return true;
350 case SFMT_F32: CVT_F32_TO_XI(int8_t, uint8_t) return true;
351 case SFMT_F64: CVT_F64_TO_XI(int8_t, uint8_t) return true;
352
353 default:
354 break;
355 }
356
357 return false;
358 }
359
360 bool convert_to_16bit(void *dst, void *src, size_t samples, size_t to, size_t from)
361 {
362 int sign = sformat_sign(to);
363 if (sign < 0)
364 return false;
365 uint16_t *dptr = static_cast<uint16_t *>(dst);
366
367 switch (sformat_format(from))
368 {
369 case SFMT_U8: CVT_UI_TO_XI(uint16_t, uint8_t, << 8) return true;
370 case SFMT_S8: CVT_SI_TO_XI(uint16_t, uint8_t, << 8) return true;
371
372 case SFMT_U16:
373 if (sign) CVT_UI_TO_SI(uint16_t, uint16_t, )
374 else ::memcpy(dptr, src, samples * sizeof(uint16_t));
375 return true;
376 case SFMT_S16:
377 if (sign) ::memcpy(dptr, src, samples * sizeof(uint16_t));
378 else CVT_SI_TO_UI(uint16_t, uint16_t, )
379 return true;
380
381 case SFMT_U24: CVT_U24_TO_XI(uint16_t, >> 8) return true;
382 case SFMT_S24: CVT_S24_TO_XI(uint16_t, >> 8) return true;
383 case SFMT_U32: CVT_UI_TO_XI(uint16_t, uint32_t, >> 16) return true;
384 case SFMT_S32: CVT_SI_TO_XI(uint16_t, uint32_t, >> 16) return true;
385 case SFMT_F32: CVT_F32_TO_XI(int16_t, uint16_t) return true;
386 case SFMT_F64: CVT_F64_TO_XI(int16_t, uint16_t) return true;
387
388 default:
389 break;
390 }
391
392 return false;
393 }
394
395 bool convert_to_24bit(void *dst, void *src, size_t samples, size_t to, size_t from)
396 {
397 int sign = sformat_sign(to);
398 if (sign < 0)
399 return false;
400 uint8_t *dptr = static_cast<uint8_t *>(dst);
401
402 switch (sformat_format(from))
403 {
404 case SFMT_U8: CVT_UI_TO_XI24(uint8_t, << 16) return true;
405 case SFMT_S8: CVT_SI_TO_XI24(uint8_t, << 16) return true;
406
407 case SFMT_U16: CVT_UI_TO_XI24(uint16_t, << 8) return true;
408 case SFMT_S16: CVT_SI_TO_XI24(uint16_t, << 8) return true;
409
410 case SFMT_U24:
411 if (sign) CVT_UI24_TO_SI24()
412 else ::memcpy(dptr, src, samples * sizeof(uint8_t) * 3);
413 return true;
414 case SFMT_S24:
415 if (sign) ::memcpy(dptr, src, samples * sizeof(uint8_t) * 3);
416 else CVT_SI24_TO_UI24()
417 return true;
418
419 case SFMT_U32: CVT_UI_TO_XI24(uint32_t, >> 8) return true;
420 case SFMT_S32: CVT_SI_TO_XI24(uint32_t, >> 8) return true;
421 case SFMT_F32: CVT_FX_TO_XI24(f32_t) return true;
422 case SFMT_F64: CVT_FX_TO_XI24(f64_t) return true;
423
424 default:
425 break;
426 }
427
428 return false;
429 }
430
431 bool convert_to_32bit(void *dst, void *src, size_t samples, size_t to, size_t from)
432 {
433 int sign = sformat_sign(to);
434 if (sign < 0)
435 return false;
436 uint32_t *dptr = static_cast<uint32_t *>(dst);
437
438 switch (sformat_format(from))
439 {
440 case SFMT_U8: CVT_UI_TO_XI(uint32_t, uint8_t, << 24) return true;
441 case SFMT_S8: CVT_SI_TO_XI(uint32_t, uint8_t, << 24) return true;
442
443 case SFMT_U16: CVT_UI_TO_XI(uint32_t, uint16_t, << 16) return true;
444 case SFMT_S16: CVT_SI_TO_XI(uint32_t, uint16_t, << 16) return true;
445
446 case SFMT_U24: CVT_U24_TO_XI(uint32_t, << 8) return true;
447 case SFMT_S24: CVT_S24_TO_XI(uint32_t, << 8) return true;
448
449 case SFMT_U32:
450 if (sign) CVT_UI_TO_SI(uint32_t, uint32_t, )
451 else ::memcpy(dptr, src, samples * sizeof(uint32_t));
452 return true;
453 case SFMT_S32:
454 if (sign) ::memcpy(dptr, src, samples * sizeof(uint32_t));
455 else CVT_SI_TO_UI(uint32_t, uint32_t, )
456 return true;
457
458 case SFMT_F32: CVT_FX_TO_XI32(f32_t) return true;
459 case SFMT_F64: CVT_FX_TO_XI32(f64_t) return true;
460
461 default:
462 break;
463 }
464
465 return false;
466 }
467
468 bool convert_to_f32(void *dst, void *src, size_t samples, size_t to, size_t from)
469 {
470 f32_t *dptr = static_cast<f32_t *>(dst);
471
472 switch (sformat_format(from))
473 {
474 case SFMT_U8: CVT_UI_TO_FX(f32_t, int8_t) return true;
475 case SFMT_S8: CVT_SI_TO_FX(f32_t, int8_t) return true;
476 case SFMT_U16: CVT_UI_TO_FX(f32_t, int16_t) return true;
477 case SFMT_S16: CVT_SI_TO_FX(f32_t, int16_t) return true;
478
479 case SFMT_U24: CVT_U24_TO_FX(f32_t) return true;
480 case SFMT_S24: CVT_S24_TO_FX(f32_t) return true;
481
482 case SFMT_U32: CVT_UI_TO_FX(f32_t, int32_t) return true;
483 case SFMT_S32: CVT_SI_TO_FX(f32_t, int32_t) return true;
484
485 case SFMT_F32:
486 ::memcpy(dptr, src, samples * sizeof(f32_t));
487 return true;
488 case SFMT_F64: CVT_FX_TO_FX(f32_t, f64_t) return true;
489
490 default:
491 break;
492 }
493
494 return false;
495 }
496
497 bool convert_to_f64(void *dst, void *src, size_t samples, size_t to, size_t from)
498 {
499 f64_t *dptr = static_cast<f64_t *>(dst);
500
501 switch (sformat_format(from))
502 {
503 case SFMT_U8: CVT_UI_TO_FX(f64_t, int8_t) return true;
504 case SFMT_S8: CVT_SI_TO_FX(f64_t, int8_t) return true;
505
506 case SFMT_U16: CVT_UI_TO_FX(f64_t, int16_t) return true;
507 case SFMT_S16: CVT_SI_TO_FX(f64_t, int16_t) return true;
508
509 case SFMT_U24: CVT_U24_TO_FX(f64_t) return true;
510 case SFMT_S24: CVT_S24_TO_FX(f64_t) return true;
511
512 case SFMT_U32: CVT_UI_TO_FX(f64_t, int32_t) return true;
513 case SFMT_S32: CVT_SI_TO_FX(f64_t, int32_t) return true;
514
515 case SFMT_F32: CVT_FX_TO_FX(f64_t, f32_t) return true;
516 case SFMT_F64:
517 ::memcpy(dptr, src, samples * sizeof(f64_t));
518 return true;
519
520 default:
521 break;
522 }
523
524 return false;
525 }
526
527 bool convert_samples(void *dst, void *src, size_t samples, size_t to, size_t from)
528 {
529 // Convert source sample endianess
530 if (!sample_endian_swap(src, samples, from))
531 return false;
532
533 // Apply sample conversion
534 switch (sformat_format(to))
535 {
536 case SFMT_U8:
537 case SFMT_S8:
538 return convert_to_8bit(dst, src, samples, to, from);
539
540 case SFMT_U16:
541 case SFMT_S16:
542 return convert_to_16bit(dst, src, samples, to, from);
543
544 case SFMT_U24:
545 case SFMT_S24:
546 return convert_to_24bit(dst, src, samples, to, from);
547
548 case SFMT_U32:
549 case SFMT_S32:
550 return convert_to_32bit(dst, src, samples, to, from);
551
552 case SFMT_F32:
553 return convert_to_f32(dst, src, samples, to, from);
554
555 case SFMT_F64:
556 return convert_to_f64(dst, src, samples, to, from);
557
558 default:
559 break;
560 }
561
562 // Convert target sample endianess
563 if (!sample_endian_swap(dst, samples, to))
564 return false;
565
566 return false;
567 }
568
569
570 } /* namespace mm */
571 } /* namespace lsp */
572
573