Lines Matching +full:big +full:- +full:endian +full:- +full:desc
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
4 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org>
36 * - http://ccrma.stanford.edu/~jos/resample/
39 * + all out fixed point integer operations, no soft-float or anything like
48 * - The z, z_, and Z_ . Due to mental block (or maybe just 0x7a69), I
124 int32_t bps; /* bytes-per-sample */
164 &feeder_rate_presets, 0, "compile-time rate presets");
176 if (err != 0 || req->newptr == NULL || val == feeder_rate_min)
199 if (err != 0 || req->newptr == NULL || val == feeder_rate_max)
222 if (err != 0 || req->newptr == NULL || val == feeder_rate_round)
228 feeder_rate_round = val - (val % Z_ROUNDHZ);
248 if (err != 0 || req->newptr == NULL || val == feeder_rate_quality)
272 if (f == NULL || f->data == NULL || CHN_STARTED(c)) {
295 #define Z_IS_ZOH(i) ((i)->quality == Z_QUALITY_ZOH)
296 #define Z_IS_LINEAR(i) ((i)->quality == Z_QUALITY_LINEAR)
297 #define Z_IS_SINC(i) ((i)->quality > Z_QUALITY_LINEAR)
307 * sample-time.
346 Z_DIV(((_Z_GCAST((i)->z_gx) * (v)) + ((i)->z_gy - (a) - 1)), \
347 (i)->z_gy)
350 Z_DIV(((_Z_GCAST((i)->z_gy) * (v)) + (a)), (i)->z_gx)
353 ((_Z_GCAST((i)->z_gy) * (x)) - (_Z_GCAST((i)->z_gx) * (y)))
355 #define z_gy2gx(i, v) _Z_GY2GX(i, (i)->z_alpha, v)
356 #define z_gx2gy(i, v) _Z_GX2GY(i, (i)->z_alpha, v)
362 #define Z_SINC_COEFF_IDX(i) ((i)->quality - Z_QUALITY_LINEAR - 1)
366 Z_SHIFT) / (i)->z_dy))
369 ((z_coeff_tab[Z_SINC_COEFF_IDX(i)].len - 1) >> (Z_DRIFT_SHIFT - 1))
378 #define z_align(i, v) ((v) & (i)->z_mask)
380 #define z_prev(i, o, v) z_align(i, (o) - (v))
381 #define z_fetched(i) (z_align(i, (i)->z_pos - (i)->z_start) - 1)
382 #define z_free(i) ((i)->z_full - (i)->z_pos)
437 cnt = info->channels * info->bps;
438 src = info->z_delay + (info->z_start * cnt);
446 } while (--cnt != 0);
456 #define Z_DECLARE_LINEAR(SIGN, BIT, ENDIAN) \
458 z_feed_linear_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
465 z = ((uint32_t)info->z_alpha * info->z_dx) >> Z_LINEAR_UNSHIFT; \
467 sx = info->z_delay + (info->z_start * info->channels * \
469 sy = sx - (info->channels * PCM_##BIT##_BPS); \
471 ch = info->channels; \
474 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(sx); \
475 y = _PCM_READ_##SIGN##BIT##_##ENDIAN(sy); \
477 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x); \
481 } while (--ch != 0); \
515 #define _Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, adv) \
519 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \
521 z += info->z_dy; \
522 p adv##= info->channels * PCM_##BIT##_BPS
540 #define Z_DECLARE_SINC(SIGN, BIT, ENDIAN) \
542 z_feed_sinc_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
550 z_coeff = info->z_coeff; \
551 z_dcoeff = info->z_dcoeff; \
552 center = z_prev(info, info->z_start, info->z_size); \
553 ch = info->channels * PCM_##BIT##_BPS; \
557 dst -= PCM_##BIT##_BPS; \
558 ch -= PCM_##BIT##_BPS; \
560 z = info->z_alpha * info->z_dx; \
562 p = info->z_delay + (z_next(info, center, 1) * \
563 info->channels * PCM_##BIT##_BPS) + ch; \
564 for (i = info->z_size; i != 0; i -= Z_SINC_ACCUMULATE_DECR) \
565 Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, +); \
566 z = info->z_dy - (info->z_alpha * info->z_dx); \
568 p = info->z_delay + (center * info->channels * \
570 for (i = info->z_size; i != 0; i -= Z_SINC_ACCUMULATE_DECR) \
571 Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, -); \
572 if (info->z_scale != Z_ONE) \
573 v = Z_SCALE_##BIT(v, info->z_scale); \
575 v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \
577 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \
581 #define Z_DECLARE_SINC_POLYPHASE(SIGN, BIT, ENDIAN) \
583 z_feed_sinc_polyphase_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
590 ch = info->channels * PCM_##BIT##_BPS; \
592 start = z_prev(info, info->z_start, (info->z_size << 1) - 1) * ch; \
595 dst -= PCM_##BIT##_BPS; \
596 ch -= PCM_##BIT##_BPS; \
598 p = info->z_delay + start + ch; \
599 z_pcoeff = info->z_pcoeff + \
600 ((info->z_alpha * info->z_size) << 1); \
601 for (i = info->z_size; i != 0; i--) { \
602 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \
605 p += info->channels * PCM_##BIT##_BPS; \
606 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \
609 p += info->channels * PCM_##BIT##_BPS; \
611 if (info->z_scale != Z_ONE) \
612 v = Z_SCALE_##BIT(v, info->z_scale); \
614 v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \
616 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \
620 #define Z_DECLARE(SIGN, BIT, ENDIAN) \
621 Z_DECLARE_LINEAR(SIGN, BIT, ENDIAN) \
622 Z_DECLARE_SINC(SIGN, BIT, ENDIAN) \
623 Z_DECLARE_SINC_POLYPHASE(SIGN, BIT, ENDIAN)
655 (Z_IS_SINC(i) ? Z_RESAMPLER_SINC : (i)->quality)
657 #define Z_RESAMPLER_ENTRY(SIGN, BIT, ENDIAN) \
659 AFMT_##SIGN##BIT##_##ENDIAN, \
662 [Z_RESAMPLER_LINEAR] = z_feed_linear_##SIGN##BIT##ENDIAN, \
663 [Z_RESAMPLER_SINC] = z_feed_sinc_##SIGN##BIT##ENDIAN, \
665 z_feed_sinc_polyphase_##SIGN##BIT##ENDIAN \
702 info->src = info->rsrc - (info->rsrc % ((feeder_rate_round > 0 &&
703 info->rsrc > feeder_rate_round) ? feeder_rate_round : 1));
704 info->dst = info->rdst - (info->rdst % ((feeder_rate_round > 0 &&
705 info->rdst > feeder_rate_round) ? feeder_rate_round : 1));
706 info->z_gx = 1;
707 info->z_gy = 1;
708 info->z_alpha = 0;
709 info->z_resample = NULL;
710 info->z_size = 1;
711 info->z_coeff = NULL;
712 info->z_dcoeff = NULL;
713 if (info->z_pcoeff != NULL) {
714 free(info->z_pcoeff, M_DEVBUF);
715 info->z_pcoeff = NULL;
717 info->z_scale = Z_ONE;
718 info->z_dx = Z_FULL_ONE;
719 info->z_dy = Z_FULL_ONE;
721 info->z_cycle = 0;
723 if (info->quality < Z_QUALITY_MIN)
724 info->quality = Z_QUALITY_MIN;
725 else if (info->quality > Z_QUALITY_MAX)
726 info->quality = Z_QUALITY_MAX;
744 z = info->z_dy;
751 z += info->z_dy;
761 return (-1);
805 * "Polynomial Interpolators for High-Quality Resampling of Oversampled Audio"
807 * - http://www.student.oulu.fi/~oniemita/dsp/deip.pdf
816 /* 1-point, 0th-order (Zero Order Hold) */
822 /* 2-point, 1st-order Linear */
824 zl1 = z_coeff[1] - z_coeff[0];
830 /* 3-point, 2nd-order Quadratic */
832 zq1 = z_coeff[1] - z_coeff[-1];
833 zq2 = z_coeff[1] + z_coeff[-1] - (z_coeff[0] << 1);
840 /* 4-point, 3rd-order Hermite */
842 zh1 = z_coeff[1] - z_coeff[-1];
843 zh2 = (z_coeff[-1] << 1) - (z_coeff[0] * 5) + (z_coeff[1] << 2) -
845 zh3 = z_coeff[2] - z_coeff[-1] + ((z_coeff[0] - z_coeff[1]) * 3);
852 /* 4-point, 3rd-order B-Spline */
854 z_coeff[-1] + z_coeff[1]), 30);
855 zb1 = z_coeff[1] - z_coeff[-1];
856 zb2 = z_coeff[-1] + z_coeff[1] - (z_coeff[0] << 1);
857 zb3 = Z_RSHIFT(0x15555555LL * (((z_coeff[0] - z_coeff[1]) * 3) +
858 z_coeff[2] - z_coeff[-1]), 30);
866 /* 6-point, 5th-order Optimal 32x */
867 zoz = z - (Z_ONE >> 1);
869 zoe2 = z_coeff[2] + z_coeff[-1];
870 zoe3 = z_coeff[3] + z_coeff[-2];
871 zoo1 = z_coeff[1] - z_coeff[0];
872 zoo2 = z_coeff[2] - z_coeff[-1];
873 zoo3 = z_coeff[3] - z_coeff[-2];
879 zoc2 = Z_RSHIFT((-0x0d3e94a4LL * zoe1) + (0x0bddded4LL * zoe2) +
881 zoc3 = Z_RSHIFT((-0x0de10cc4LL * zoo1) + (0x019b2a7dLL * zoo2) +
883 zoc4 = Z_RSHIFT((0x02aa12d7LL * zoe1) + (-0x03ff1bb3LL * zoe2) +
885 zoc5 = Z_RSHIFT((0x051d29e5LL * zoo1) + (-0x028e7647LL * zoo2) +
896 /* 6-point, 5th-order Optimal 16x */
897 zoz = z - (Z_ONE >> 1);
899 zoe2 = z_coeff[2] + z_coeff[-1];
900 zoe3 = z_coeff[3] + z_coeff[-2];
901 zoo1 = z_coeff[1] - z_coeff[0];
902 zoo2 = z_coeff[2] - z_coeff[-1];
903 zoo3 = z_coeff[3] - z_coeff[-2];
909 zoc2 = Z_RSHIFT((-0x0d3e94a4LL * zoe1) + (0x0bddded4LL * zoe2) +
911 zoc3 = Z_RSHIFT((-0x0de10cc4LL * zoo1) + (0x019b2a7dLL * zoo2) +
913 zoc4 = Z_RSHIFT((0x02aa12d7LL * zoe1) + (-0x03ff1bb3LL * zoe2) +
915 zoc5 = Z_RSHIFT((0x051d29e5LL * zoo1) + (-0x028e7647LL * zoo2) +
926 /* 6-point, 5th-order Optimal 8x */
927 zoz = z - (Z_ONE >> 1);
929 zoe2 = z_coeff[2] + z_coeff[-1];
930 zoe3 = z_coeff[3] + z_coeff[-2];
931 zoo1 = z_coeff[1] - z_coeff[0];
932 zoo2 = z_coeff[2] - z_coeff[-1];
933 zoo3 = z_coeff[3] - z_coeff[-2];
939 zoc2 = Z_RSHIFT((-0x0d22530bLL * zoe1) + (0x0bb37a2cLL * zoe2) +
941 zoc3 = Z_RSHIFT((-0x0d744b1cLL * zoo1) + (0x01649591LL * zoo2) +
943 zoc4 = Z_RSHIFT((0x02a7ee1bLL * zoe1) + (-0x03fbdb24LL * zoe2) +
945 zoc5 = Z_RSHIFT((0x04cf9b6cLL * zoo1) + (-0x0266b378LL * zoo2) +
956 /* 6-point, 5th-order Optimal 4x */
957 zoz = z - (Z_ONE >> 1);
959 zoe2 = z_coeff[2] + z_coeff[-1];
960 zoe3 = z_coeff[3] + z_coeff[-2];
961 zoo1 = z_coeff[1] - z_coeff[0];
962 zoo2 = z_coeff[2] - z_coeff[-1];
963 zoo3 = z_coeff[3] - z_coeff[-2];
969 zoc2 = Z_RSHIFT((-0x0d026821LL * zoe1) + (0x0b837773LL * zoe2) +
971 zoc3 = Z_RSHIFT((-0x0cef1502LL * zoo1) + (0x01207a8eLL * zoo2) +
973 zoc4 = Z_RSHIFT((0x029fe643LL * zoe1) + (-0x03ef3fc8LL * zoe2) +
975 zoc5 = Z_RSHIFT((0x043a9d08LL * zoo1) + (-0x02154febLL * zoo2) +
986 /* 6-point, 5th-order Optimal 2x */
987 zoz = z - (Z_ONE >> 1);
989 zoe2 = z_coeff[2] + z_coeff[-1];
990 zoe3 = z_coeff[3] + z_coeff[-2];
991 zoo1 = z_coeff[1] - z_coeff[0];
992 zoo2 = z_coeff[2] - z_coeff[-1];
993 zoo3 = z_coeff[3] - z_coeff[-2];
999 zoc2 = Z_RSHIFT((-0x0c3ee068LL * zoe1) + (0x0a5c3769LL * zoe2) +
1001 zoc3 = Z_RSHIFT((-0x0a8ab614LL * zoo1) + (-0x0019522eLL * zoo2) +
1003 zoc4 = Z_RSHIFT((0x0276187dLL * zoe1) + (-0x03a801e8LL * zoe2) +
1005 zoc5 = Z_RSHIFT((0x02c373f5LL * zoo1) + (-0x01275f83LL * zoo2) +
1028 if (info->z_pcoeff != NULL) {
1029 free(info->z_pcoeff, M_DEVBUF);
1030 info->z_pcoeff = NULL;
1036 if (((int64_t)info->z_size * info->z_gy * 2) >
1040 info->z_gx, info->z_gy,
1041 (intmax_t)info->z_size * info->z_gy * 2,
1047 info->z_pcoeff = malloc(sizeof(int32_t) *
1048 info->z_size * info->z_gy * 2, M_DEVBUF, M_NOWAIT | M_ZERO);
1049 if (info->z_pcoeff == NULL)
1052 for (alpha = 0; alpha < info->z_gy; alpha++) {
1053 z = alpha * info->z_dx;
1055 for (i = info->z_size; i != 0; i--) {
1058 idx = (alpha * info->z_size * 2) +
1059 (info->z_size * 2) - i;
1060 info->z_pcoeff[idx] =
1061 z_coeff_interpolate(z, info->z_coeff + c);
1062 z += info->z_dy;
1064 z = info->z_dy - (alpha * info->z_dx);
1066 for (i = info->z_size; i != 0; i--) {
1069 idx = (alpha * info->z_size * 2) + i - 1;
1070 info->z_pcoeff[idx] =
1071 z_coeff_interpolate(z, info->z_coeff + c);
1072 z += info->z_dy;
1078 info->z_gx, info->z_gy, info->z_size * info->z_gy * 2);
1093 info = f->data;
1096 if (info->src == info->dst)
1100 i = z_gcd(info->src, info->dst);
1101 info->z_gx = info->src / i;
1102 info->z_gy = info->dst / i;
1104 /* Too big, or too small. Bail out. */
1105 if (!(Z_FACTOR_SAFE(info->z_gx) && Z_FACTOR_SAFE(info->z_gy)))
1108 format = f->desc->in;
1122 if (info->z_gx > info->z_gy)
1125 * enable semi-adaptive mode. Although handling
1130 if ((info->z_gx / info->z_gy) > Z_SINC_DOWNMAX)
1133 z_scale = ((uint64_t)info->z_gy << Z_SHIFT) /
1134 info->z_gx;
1153 if (info->z_pcoeff != NULL) {
1154 free(info->z_pcoeff, M_DEVBUF);
1155 info->z_pcoeff = NULL;
1159 info->z_dy = z_scale << Z_DRIFT_SHIFT;
1160 if (info->z_dy < 1)
1162 info->z_scale = z_scale;
1164 info->z_dy = Z_FULL_ONE;
1165 info->z_scale = Z_ONE;
1169 info->z_dx = info->z_dy / info->z_gy;
1175 if (info->z_dx < 1) {
1186 info->z_dy = info->z_dx * info->z_gy;
1197 info->z_size = z_resampler_sinc_len(info);
1203 info->z_size &= ~1;
1205 if (info->z_size < 2 || info->z_size > Z_SINC_MAX) {
1212 info->z_coeff = z_coeff_tab[i].coeff + Z_COEFF_OFFSET;
1213 info->z_dcoeff = z_coeff_tab[i].dcoeff;
1217 if (info->z_coeff == NULL || info->z_dcoeff == NULL)
1225 info->z_dx = Z_LINEAR_FULL_ONE / info->z_gy;
1242 info->z_resample = z_resampler_tab[i].resampler[ridx];
1246 if (info->z_resample == NULL)
1249 info->bps = AFMT_BPS(format);
1250 align = info->channels * info->bps;
1261 * Now that is damn confusing, I guess ;-) .
1263 gy2gx_max = (((uint64_t)info->z_gy * INT32_MAX) - info->z_gy + 1) /
1264 info->z_gx;
1272 gx2gy_max = (((uint64_t)info->z_gx * INT32_MAX) - info->z_gy) /
1273 info->z_gy;
1289 info->z_maxfeed = gy2gx_max * align;
1292 info->z_startdrift = z_gy2gx(info, 1);
1293 info->z_alphadrift = z_drift(info, info->z_startdrift, 1);
1297 info->z_full = z_roundpow2((info->z_size << 1) + i);
1300 * Too big to be true, and overflowing left and right like mad ..
1302 if ((info->z_full * align) < 1) {
1314 while (info->z_full < Z_RESERVOIR_MAX &&
1315 (info->z_full - (info->z_size << 1)) < Z_RESERVOIR)
1316 info->z_full <<= 1;
1319 info->z_mask = info->z_full - 1;
1320 info->z_start = z_prev(info, info->z_size << 1, 1);
1321 info->z_pos = z_next(info, info->z_start, 1);
1326 i = info->z_full * align;
1330 if (info->z_delay == NULL || info->z_alloc < i ||
1331 i <= (info->z_alloc >> 1)) {
1332 if (info->z_delay != NULL)
1333 free(info->z_delay, M_DEVBUF);
1334 info->z_delay = malloc(i, M_DEVBUF, M_NOWAIT | M_ZERO);
1335 if (info->z_delay == NULL)
1337 info->z_alloc = i;
1343 memset(info->z_delay, sndbuf_zerodata(f->desc->out),
1344 info->z_pos * align);
1350 #define dumpz(x) fprintf(stderr, "\t%12s = %10u : %-11d\n", \
1351 "z_"__STRING(x), (uint32_t)info->z_##x, \
1352 (int32_t)info->z_##x)
1355 info->channels, info->bps, format, info->quality);
1356 fprintf(stderr, "\t%d (%d) -> %d (%d), ",
1357 info->src, info->rsrc, info->dst, info->rdst);
1358 fprintf(stderr, "[%d/%d]\n", info->z_gx, info->z_gy);
1368 if (info->z_alloc < 1024)
1370 "", info->z_alloc);
1371 else if (info->z_alloc < (1024 << 10))
1373 "", info->z_alloc >> 10);
1374 else if (info->z_alloc < (1024 << 20))
1376 "", info->z_alloc >> 20);
1379 "", info->z_alloc >> 30);
1382 (int32_t)z_gx2gy(info, info->z_full - (info->z_size << 1)));
1385 (int32_t)z_gx2gy(info, (info->z_alloc / align) -
1386 (info->z_size << 1)));
1389 fprintf(stderr, "\t%12s = %10d -> z_gy2gx() -> %d\n",
1393 fprintf(stderr, "\t%12s = %10d -> z_gx2gy() -> %d\n",
1401 (double)info->z_scale / Z_ONE);
1404 (double)info->z_dx / info->z_dy);
1407 info->z_dy >> Z_SHIFT);
1409 (z_scale << Z_DRIFT_SHIFT) - info->z_dy);
1425 info = f->data;
1431 if (value == info->rsrc)
1433 info->rsrc = value;
1438 if (value == info->rdst)
1440 info->rdst = value;
1445 if (value == info->quality)
1453 oquality = info->quality;
1454 info->quality = value;
1457 info->quality = oquality;
1462 if (value == info->channels)
1464 info->channels = value;
1479 info = f->data;
1483 return (info->rsrc);
1486 return (info->rdst);
1489 return (info->quality);
1492 return (info->channels);
1498 return (-1);
1507 if (f->desc->in != f->desc->out)
1514 info->rsrc = Z_RATE_DEFAULT;
1515 info->rdst = Z_RATE_DEFAULT;
1516 info->quality = feeder_rate_quality;
1517 info->channels = AFMT_CHANNEL(f->desc->in);
1519 f->data = info;
1523 if (info->z_pcoeff != NULL)
1524 free(info->z_pcoeff, M_DEVBUF);
1525 if (info->z_delay != NULL)
1526 free(info->z_delay, M_DEVBUF);
1528 f->data = NULL;
1539 info = f->data;
1541 if (info->z_pcoeff != NULL)
1542 free(info->z_pcoeff, M_DEVBUF);
1543 if (info->z_delay != NULL)
1544 free(info->z_delay, M_DEVBUF);
1548 f->data = NULL;
1562 info = f->data;
1563 if (info->z_resample == NULL)
1564 return (z_feed(f->source, c, b, count, source));
1571 align = info->channels * info->bps;
1580 reqin = z_gy2gx(info, ocount) - z_fetched(info);
1583 startdrift = info->z_startdrift;
1584 alphadrift = info->z_alphadrift;
1602 start = z_prev(info, info->z_start,
1603 (info->z_size << 1) - 1);
1604 cp = (info->z_size << 1) + fetched;
1605 z_copy(info->z_delay + (start * align),
1606 info->z_delay, cp * align);
1607 info->z_start =
1608 z_prev(info, info->z_size << 1, 1);
1609 info->z_pos =
1610 z_next(info, info->z_start, fetched + 1);
1619 start, fetched, cp, info->z_cycle,
1622 info->z_cycle = 0;
1630 fetched = SND_FXDIV(z_feed(f->source, c,
1631 info->z_delay + (info->z_pos * align),
1638 reqin -= fetched;
1639 info->z_pos += fetched;
1647 ocount -= reqout;
1660 info->z_resample(info, dst);
1661 info->z_alpha += alphadrift;
1662 if (info->z_alpha < info->z_gy)
1663 info->z_start += startdrift;
1665 info->z_start += startdrift - 1;
1666 info->z_alpha -= info->z_gy;
1670 info->z_cycle++;
1672 } while (--reqout != 0);
1679 return (dst - b);
1691 maxfeed = ((struct z_info *)(f->data))->z_maxfeed;
1698 left -= feed;
1701 return (count - left);