54#ifdef HAVE_KERNEL_OPTION_HEADERS
62#include "snd_fxdiv_gen.h"
67#include "feeder_rate_gen.h"
69#if !defined(_KERNEL) && defined(SND_DIAGNOSTIC)
76#ifndef Z_QUALITY_DEFAULT
77#define Z_QUALITY_DEFAULT Z_QUALITY_LINEAR
80#define Z_RESERVOIR 2048
81#define Z_RESERVOIR_MAX 131072
83#define Z_SINC_MAX 0x3fffff
84#define Z_SINC_DOWNMAX 48
87#define Z_POLYPHASE_MAX 183040
89#define Z_POLYPHASE_MAX 1464320
92#define Z_RATE_DEFAULT 48000
94#define Z_RATE_MIN FEEDRATE_RATEMIN
95#define Z_RATE_MAX FEEDRATE_RATEMAX
96#define Z_ROUNDHZ FEEDRATE_ROUNDHZ
97#define Z_ROUNDHZ_MIN FEEDRATE_ROUNDHZ_MIN
98#define Z_ROUNDHZ_MAX FEEDRATE_ROUNDHZ_MAX
100#define Z_RATE_SRC FEEDRATE_SRC
101#define Z_RATE_DST FEEDRATE_DST
102#define Z_RATE_QUALITY FEEDRATE_QUALITY
103#define Z_RATE_CHANNELS FEEDRATE_CHANNELS
107#define Z_MULTIFORMAT 1
110#undef Z_USE_ALPHADRIFT
111#define Z_USE_ALPHADRIFT 1
114#define Z_FACTOR_MIN 1
115#define Z_FACTOR_MAX Z_MASK
116#define Z_FACTOR_SAFE(v) (!((v) < Z_FACTOR_MIN || (v) > Z_FACTOR_MAX))
138#ifdef Z_USE_ALPHADRIFT
176 err = sysctl_handle_int(oidp, &
val, 0,
req);
189 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0,
sizeof(
int),
191 "minimum allowable rate");
199 err = sysctl_handle_int(oidp, &
val, 0,
req);
212 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0,
sizeof(
int),
214 "maximum allowable rate");
222 err = sysctl_handle_int(oidp, &
val, 0,
req);
235 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0,
sizeof(
int),
237 "sample rate converter rounding threshold");
248 err = sysctl_handle_int(oidp, &
val, 0,
req);
253 if (val < Z_QUALITY_MIN || val > Z_QUALITY_MAX)
288 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0,
sizeof(
int),
290 "sample rate converter quality ("__XSTRING(Z_QUALITY_MIN)
"=low .. "
291 __XSTRING(Z_QUALITY_MAX)
"=high)");
297#define Z_IS_ZOH(i) ((i)->quality == Z_QUALITY_ZOH)
298#define Z_IS_LINEAR(i) ((i)->quality == Z_QUALITY_LINEAR)
299#define Z_IS_SINC(i) ((i)->quality > Z_QUALITY_LINEAR)
311#define _Z_GCAST(x) ((uint64_t)(x))
313#if defined(__GNUCLIKE_ASM) && defined(__i386__)
323static __inline uint32_t
324Z_DIV(uint64_t v, uint32_t d)
326 uint32_t hi, lo, quo, rem;
338 :
"=a" (quo),
"=d" (rem)
339 :
"r" (d),
"0" (lo),
"1" (hi));
344#define Z_DIV(x, y) ((x) / (y))
347#define _Z_GY2GX(i, a, v) \
348 Z_DIV(((_Z_GCAST((i)->z_gx) * (v)) + ((i)->z_gy - (a) - 1)), \
351#define _Z_GX2GY(i, a, v) \
352 Z_DIV(((_Z_GCAST((i)->z_gy) * (v)) + (a)), (i)->z_gx)
354#define _Z_DRIFT(i, x, y) \
355 ((_Z_GCAST((i)->z_gy) * (x)) - (_Z_GCAST((i)->z_gx) * (y)))
357#define z_gy2gx(i, v) _Z_GY2GX(i, (i)->z_alpha, v)
358#define z_gx2gy(i, v) _Z_GX2GY(i, (i)->z_alpha, v)
359#define z_drift(i, x, y) _Z_DRIFT(i, x, y)
364#define Z_SINC_COEFF_IDX(i) ((i)->quality - Z_QUALITY_LINEAR - 1)
366#define Z_SINC_LEN(i) \
367 ((int32_t)(((uint64_t)z_coeff_tab[Z_SINC_COEFF_IDX(i)].len << \
368 Z_SHIFT) / (i)->z_dy))
370#define Z_SINC_BASE_LEN(i) \
371 ((z_coeff_tab[Z_SINC_COEFF_IDX(i)].len - 1) >> (Z_DRIFT_SHIFT - 1))
380#define z_align(i, v) ((v) & (i)->z_mask)
381#define z_next(i, o, v) z_align(i, (o) + (v))
382#define z_prev(i, o, v) z_align(i, (o) - (v))
383#define z_fetched(i) (z_align(i, (i)->z_pos - (i)->z_start) - 1)
384#define z_free(i) ((i)->z_full - (i)->z_pos)
389#define z_copy(src, dst, sz) (void)memcpy(dst, src, sz)
390#define z_feed(...) FEEDER_FEED(__VA_ARGS__)
392static __inline uint32_t
396 return ((x < y) ? x : y);
423 while (i > 0 && i < v)
453 }
while (--cnt != 0);
464#define Z_DECLARE_LINEAR(SIGN, BIT, ENDIAN) \
466z_feed_linear_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
473 z = ((uint32_t)info->z_alpha * info->z_dx) >> Z_LINEAR_UNSHIFT; \
475 sx = info->z_delay + (info->z_start * info->channels * \
477 sy = sx - (info->channels * PCM_##BIT##_BPS); \
479 ch = info->channels; \
482 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(sx); \
483 y = _PCM_READ_##SIGN##BIT##_##ENDIAN(sy); \
484 x = Z_LINEAR_INTERPOLATE_##BIT(z, x, y); \
485 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x); \
486 sx += PCM_##BIT##_BPS; \
487 sy += PCM_##BIT##_BPS; \
488 dst += PCM_##BIT##_BPS; \
489 } while (--ch != 0); \
500#define Z_CLIP_CHECK(v, BIT) do { \
501 if ((v) > PCM_S##BIT##_MAX) { \
502 fprintf(stderr, "Overflow: v=%jd, max=%jd\n", \
503 (intmax_t)(v), (intmax_t)PCM_S##BIT##_MAX); \
504 } else if ((v) < PCM_S##BIT##_MIN) { \
505 fprintf(stderr, "Underflow: v=%jd, min=%jd\n", \
506 (intmax_t)(v), (intmax_t)PCM_S##BIT##_MIN); \
510#define Z_CLIP_CHECK(...)
513#define Z_CLAMP(v, BIT) \
514 (((v) > PCM_S##BIT##_MAX) ? PCM_S##BIT##_MAX : \
515 (((v) < PCM_S##BIT##_MIN) ? PCM_S##BIT##_MIN : (v)))
523#define _Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, adv) \
526 coeff = Z_COEFF_INTERPOLATE(z, z_coeff[c], z_dcoeff[c]); \
527 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \
528 v += Z_NORM_##BIT((intpcm64_t)x * coeff); \
530 p adv##= info->channels * PCM_##BIT##_BPS
535#if defined(__GNUC__) && __GNUC__ >= 4
536#define Z_SINC_ACCUMULATE(...) do { \
537 _Z_SINC_ACCUMULATE(__VA_ARGS__); \
538 _Z_SINC_ACCUMULATE(__VA_ARGS__); \
540#define Z_SINC_ACCUMULATE_DECR 2
542#define Z_SINC_ACCUMULATE(...) do { \
543 _Z_SINC_ACCUMULATE(__VA_ARGS__); \
545#define Z_SINC_ACCUMULATE_DECR 1
548#define Z_DECLARE_SINC(SIGN, BIT, ENDIAN) \
550z_feed_sinc_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
555 int32_t coeff, z, *z_coeff, *z_dcoeff; \
556 uint32_t c, center, ch, i; \
558 z_coeff = info->z_coeff; \
559 z_dcoeff = info->z_dcoeff; \
560 center = z_prev(info, info->z_start, info->z_size); \
561 ch = info->channels * PCM_##BIT##_BPS; \
565 dst -= PCM_##BIT##_BPS; \
566 ch -= PCM_##BIT##_BPS; \
568 z = info->z_alpha * info->z_dx; \
570 p = info->z_delay + (z_next(info, center, 1) * \
571 info->channels * PCM_##BIT##_BPS) + ch; \
572 for (i = info->z_size; i != 0; i -= Z_SINC_ACCUMULATE_DECR) \
573 Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, +); \
574 z = info->z_dy - (info->z_alpha * info->z_dx); \
576 p = info->z_delay + (center * info->channels * \
577 PCM_##BIT##_BPS) + ch; \
578 for (i = info->z_size; i != 0; i -= Z_SINC_ACCUMULATE_DECR) \
579 Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, -); \
580 if (info->z_scale != Z_ONE) \
581 v = Z_SCALE_##BIT(v, info->z_scale); \
583 v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \
584 Z_CLIP_CHECK(v, BIT); \
585 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \
589#define Z_DECLARE_SINC_POLYPHASE(SIGN, BIT, ENDIAN) \
591z_feed_sinc_polyphase_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
596 int32_t ch, i, start, *z_pcoeff; \
598 ch = info->channels * PCM_##BIT##_BPS; \
600 start = z_prev(info, info->z_start, (info->z_size << 1) - 1) * ch; \
603 dst -= PCM_##BIT##_BPS; \
604 ch -= PCM_##BIT##_BPS; \
606 p = info->z_delay + start + ch; \
607 z_pcoeff = info->z_pcoeff + \
608 ((info->z_alpha * info->z_size) << 1); \
609 for (i = info->z_size; i != 0; i--) { \
610 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \
611 v += Z_NORM_##BIT((intpcm64_t)x * *z_pcoeff); \
613 p += info->channels * PCM_##BIT##_BPS; \
614 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \
615 v += Z_NORM_##BIT((intpcm64_t)x * *z_pcoeff); \
617 p += info->channels * PCM_##BIT##_BPS; \
619 if (info->z_scale != Z_ONE) \
620 v = Z_SCALE_##BIT(v, info->z_scale); \
622 v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \
623 Z_CLIP_CHECK(v, BIT); \
624 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \
628#define Z_DECLARE(SIGN, BIT, ENDIAN) \
629 Z_DECLARE_LINEAR(SIGN, BIT, ENDIAN) \
630 Z_DECLARE_SINC(SIGN, BIT, ENDIAN) \
631 Z_DECLARE_SINC_POLYPHASE(SIGN, BIT, ENDIAN)
633#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
637#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
641#ifdef SND_FEEDER_MULTIFORMAT
662#define Z_RESAMPLER_IDX(i) \
663 (Z_IS_SINC(i) ? Z_RESAMPLER_SINC : (i)->quality)
665#define Z_RESAMPLER_ENTRY(SIGN, BIT, ENDIAN) \
667 AFMT_##SIGN##BIT##_##ENDIAN, \
669 [Z_RESAMPLER_ZOH] = z_feed_zoh, \
670 [Z_RESAMPLER_LINEAR] = z_feed_linear_##SIGN##BIT##ENDIAN, \
671 [Z_RESAMPLER_SINC] = z_feed_sinc_##SIGN##BIT##ENDIAN, \
672 [Z_RESAMPLER_SINC_POLYPHASE] = \
673 z_feed_sinc_polyphase_##SIGN##BIT##ENDIAN \
681#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
685#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
689#ifdef SND_FEEDER_MULTIFORMAT
703#define Z_RESAMPLER_TAB_SIZE \
704 ((int32_t)(sizeof(z_resampler_tab) / sizeof(z_resampler_tab[0])))
726 info->
z_dx = Z_FULL_ONE;
727 info->
z_dy = Z_FULL_ONE;
731 if (info->
quality < Z_QUALITY_MIN)
733 else if (info->
quality > Z_QUALITY_MAX)
741 int32_t
c, z,
len, lmax;
760 }
while (c < lmax && ++len > 0);
764 printf(
"%s(): sinc l=%d != Z_SINC_LEN=%d\n",
767 fprintf(stderr,
"%s(): sinc l=%d != Z_SINC_LEN=%d\n",
776#define z_resampler_sinc_len(i) (Z_IS_SINC(i) ? Z_SINC_LEN(i) : 1)
779#define Z_POLYPHASE_COEFF_SHIFT 0
785#if !(defined(Z_COEFF_INTERP_ZOH) || defined(Z_COEFF_INTERP_LINEAR) || \
786 defined(Z_COEFF_INTERP_QUADRATIC) || defined(Z_COEFF_INTERP_HERMITE) || \
787 defined(Z_COEFF_INTER_BSPLINE) || defined(Z_COEFF_INTERP_OPT32X) || \
788 defined(Z_COEFF_INTERP_OPT16X) || defined(Z_COEFF_INTERP_OPT8X) || \
789 defined(Z_COEFF_INTERP_OPT4X) || defined(Z_COEFF_INTERP_OPT2X))
790#if Z_DRIFT_SHIFT >= 6
791#define Z_COEFF_INTERP_BSPLINE 1
792#elif Z_DRIFT_SHIFT >= 5
793#define Z_COEFF_INTERP_OPT32X 1
794#elif Z_DRIFT_SHIFT == 4
795#define Z_COEFF_INTERP_OPT16X 1
796#elif Z_DRIFT_SHIFT == 3
797#define Z_COEFF_INTERP_OPT8X 1
798#elif Z_DRIFT_SHIFT == 2
799#define Z_COEFF_INTERP_OPT4X 1
800#elif Z_DRIFT_SHIFT == 1
801#define Z_COEFF_INTERP_OPT2X 1
803#error "Z_DRIFT_SHIFT screwed!"
822#if defined(Z_COEFF_INTERP_ZOH)
827#elif defined(Z_COEFF_INTERP_LINEAR)
832 zl1 = z_coeff[1] - z_coeff[0];
834 coeff = Z_RSHIFT((int64_t)zl1 * z, Z_SHIFT) + zl0;
835#elif defined(Z_COEFF_INTERP_QUADRATIC)
836 int32_t zq0, zq1, zq2;
840 zq1 = z_coeff[1] - z_coeff[-1];
841 zq2 = z_coeff[1] + z_coeff[-1] - (z_coeff[0] << 1);
843 coeff = Z_RSHIFT((Z_RSHIFT((int64_t)zq2 * z, Z_SHIFT) +
844 zq1) * z, Z_SHIFT + 1) + zq0;
845#elif defined(Z_COEFF_INTERP_HERMITE)
846 int32_t zh0, zh1, zh2, zh3;
850 zh1 = z_coeff[1] - z_coeff[-1];
851 zh2 = (z_coeff[-1] << 1) - (z_coeff[0] * 5) + (z_coeff[1] << 2) -
853 zh3 = z_coeff[2] - z_coeff[-1] + ((z_coeff[0] - z_coeff[1]) * 3);
855 coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((int64_t)zh3 * z, Z_SHIFT) +
856 zh2) * z, Z_SHIFT) + zh1) * z, Z_SHIFT + 1) + zh0;
857#elif defined(Z_COEFF_INTERP_BSPLINE)
858 int32_t zb0, zb1, zb2, zb3;
861 zb0 = Z_RSHIFT(0x15555555LL * (((int64_t)z_coeff[0] << 2) +
862 z_coeff[-1] + z_coeff[1]), 30);
863 zb1 = z_coeff[1] - z_coeff[-1];
864 zb2 = z_coeff[-1] + z_coeff[1] - (z_coeff[0] << 1);
865 zb3 = Z_RSHIFT(0x15555555LL * (((z_coeff[0] - z_coeff[1]) * 3) +
866 z_coeff[2] - z_coeff[-1]), 30);
868 coeff = (Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((int64_t)zb3 * z, Z_SHIFT) +
869 zb2) * z, Z_SHIFT) + zb1) * z, Z_SHIFT) + zb0 + 1) >> 1;
870#elif defined(Z_COEFF_INTERP_OPT32X)
871 int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3;
872 int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5;
875 zoz = z - (Z_ONE >> 1);
876 zoe1 = z_coeff[1] + z_coeff[0];
877 zoe2 = z_coeff[2] + z_coeff[-1];
878 zoe3 = z_coeff[3] + z_coeff[-2];
879 zoo1 = z_coeff[1] - z_coeff[0];
880 zoo2 = z_coeff[2] - z_coeff[-1];
881 zoo3 = z_coeff[3] - z_coeff[-2];
883 zoc0 = Z_RSHIFT((0x1ac2260dLL * zoe1) + (0x0526cdcaLL * zoe2) +
884 (0x00170c29LL * zoe3), 30);
885 zoc1 = Z_RSHIFT((0x14f8a49aLL * zoo1) + (0x0d6d1109LL * zoo2) +
886 (0x008cd4dcLL * zoo3), 30);
887 zoc2 = Z_RSHIFT((-0x0d3e94a4LL * zoe1) + (0x0bddded4LL * zoe2) +
888 (0x0160b5d0LL * zoe3), 30);
889 zoc3 = Z_RSHIFT((-0x0de10cc4LL * zoo1) + (0x019b2a7dLL * zoo2) +
890 (0x01cfe914LL * zoo3), 30);
891 zoc4 = Z_RSHIFT((0x02aa12d7LL * zoe1) + (-0x03ff1bb3LL * zoe2) +
892 (0x015508ddLL * zoe3), 30);
893 zoc5 = Z_RSHIFT((0x051d29e5LL * zoo1) + (-0x028e7647LL * zoo2) +
894 (0x0082d81aLL * zoo3), 30);
896 coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT(
897 (int64_t)zoc5 * zoz, Z_SHIFT) +
898 zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) +
899 zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0;
900#elif defined(Z_COEFF_INTERP_OPT16X)
901 int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3;
902 int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5;
905 zoz = z - (Z_ONE >> 1);
906 zoe1 = z_coeff[1] + z_coeff[0];
907 zoe2 = z_coeff[2] + z_coeff[-1];
908 zoe3 = z_coeff[3] + z_coeff[-2];
909 zoo1 = z_coeff[1] - z_coeff[0];
910 zoo2 = z_coeff[2] - z_coeff[-1];
911 zoo3 = z_coeff[3] - z_coeff[-2];
913 zoc0 = Z_RSHIFT((0x1ac2260dLL * zoe1) + (0x0526cdcaLL * zoe2) +
914 (0x00170c29LL * zoe3), 30);
915 zoc1 = Z_RSHIFT((0x14f8a49aLL * zoo1) + (0x0d6d1109LL * zoo2) +
916 (0x008cd4dcLL * zoo3), 30);
917 zoc2 = Z_RSHIFT((-0x0d3e94a4LL * zoe1) + (0x0bddded4LL * zoe2) +
918 (0x0160b5d0LL * zoe3), 30);
919 zoc3 = Z_RSHIFT((-0x0de10cc4LL * zoo1) + (0x019b2a7dLL * zoo2) +
920 (0x01cfe914LL * zoo3), 30);
921 zoc4 = Z_RSHIFT((0x02aa12d7LL * zoe1) + (-0x03ff1bb3LL * zoe2) +
922 (0x015508ddLL * zoe3), 30);
923 zoc5 = Z_RSHIFT((0x051d29e5LL * zoo1) + (-0x028e7647LL * zoo2) +
924 (0x0082d81aLL * zoo3), 30);
926 coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT(
927 (int64_t)zoc5 * zoz, Z_SHIFT) +
928 zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) +
929 zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0;
930#elif defined(Z_COEFF_INTERP_OPT8X)
931 int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3;
932 int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5;
935 zoz = z - (Z_ONE >> 1);
936 zoe1 = z_coeff[1] + z_coeff[0];
937 zoe2 = z_coeff[2] + z_coeff[-1];
938 zoe3 = z_coeff[3] + z_coeff[-2];
939 zoo1 = z_coeff[1] - z_coeff[0];
940 zoo2 = z_coeff[2] - z_coeff[-1];
941 zoo3 = z_coeff[3] - z_coeff[-2];
943 zoc0 = Z_RSHIFT((0x1aa9b47dLL * zoe1) + (0x053d9944LL * zoe2) +
944 (0x0018b23fLL * zoe3), 30);
945 zoc1 = Z_RSHIFT((0x14a104d1LL * zoo1) + (0x0d7d2504LL * zoo2) +
946 (0x0094b599LL * zoo3), 30);
947 zoc2 = Z_RSHIFT((-0x0d22530bLL * zoe1) + (0x0bb37a2cLL * zoe2) +
948 (0x016ed8e0LL * zoe3), 30);
949 zoc3 = Z_RSHIFT((-0x0d744b1cLL * zoo1) + (0x01649591LL * zoo2) +
950 (0x01dae93aLL * zoo3), 30);
951 zoc4 = Z_RSHIFT((0x02a7ee1bLL * zoe1) + (-0x03fbdb24LL * zoe2) +
952 (0x0153ed07LL * zoe3), 30);
953 zoc5 = Z_RSHIFT((0x04cf9b6cLL * zoo1) + (-0x0266b378LL * zoo2) +
954 (0x007a7c26LL * zoo3), 30);
956 coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT(
957 (int64_t)zoc5 * zoz, Z_SHIFT) +
958 zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) +
959 zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0;
960#elif defined(Z_COEFF_INTERP_OPT4X)
961 int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3;
962 int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5;
965 zoz = z - (Z_ONE >> 1);
966 zoe1 = z_coeff[1] + z_coeff[0];
967 zoe2 = z_coeff[2] + z_coeff[-1];
968 zoe3 = z_coeff[3] + z_coeff[-2];
969 zoo1 = z_coeff[1] - z_coeff[0];
970 zoo2 = z_coeff[2] - z_coeff[-1];
971 zoo3 = z_coeff[3] - z_coeff[-2];
973 zoc0 = Z_RSHIFT((0x1a8eda43LL * zoe1) + (0x0556ee38LL * zoe2) +
974 (0x001a3784LL * zoe3), 30);
975 zoc1 = Z_RSHIFT((0x143d863eLL * zoo1) + (0x0d910e36LL * zoo2) +
976 (0x009ca889LL * zoo3), 30);
977 zoc2 = Z_RSHIFT((-0x0d026821LL * zoe1) + (0x0b837773LL * zoe2) +
978 (0x017ef0c6LL * zoe3), 30);
979 zoc3 = Z_RSHIFT((-0x0cef1502LL * zoo1) + (0x01207a8eLL * zoo2) +
980 (0x01e936dbLL * zoo3), 30);
981 zoc4 = Z_RSHIFT((0x029fe643LL * zoe1) + (-0x03ef3fc8LL * zoe2) +
982 (0x014f5923LL * zoe3), 30);
983 zoc5 = Z_RSHIFT((0x043a9d08LL * zoo1) + (-0x02154febLL * zoo2) +
984 (0x00670dbdLL * zoo3), 30);
986 coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT(
987 (int64_t)zoc5 * zoz, Z_SHIFT) +
988 zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) +
989 zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0;
990#elif defined(Z_COEFF_INTERP_OPT2X)
991 int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3;
992 int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5;
995 zoz = z - (Z_ONE >> 1);
996 zoe1 = z_coeff[1] + z_coeff[0];
997 zoe2 = z_coeff[2] + z_coeff[-1];
998 zoe3 = z_coeff[3] + z_coeff[-2];
999 zoo1 = z_coeff[1] - z_coeff[0];
1000 zoo2 = z_coeff[2] - z_coeff[-1];
1001 zoo3 = z_coeff[3] - z_coeff[-2];
1003 zoc0 = Z_RSHIFT((0x19edb6fdLL * zoe1) + (0x05ebd062LL * zoe2) +
1004 (0x00267881LL * zoe3), 30);
1005 zoc1 = Z_RSHIFT((0x1223af76LL * zoo1) + (0x0de3dd6bLL * zoo2) +
1006 (0x00d683cdLL * zoo3), 30);
1007 zoc2 = Z_RSHIFT((-0x0c3ee068LL * zoe1) + (0x0a5c3769LL * zoe2) +
1008 (0x01e2aceaLL * zoe3), 30);
1009 zoc3 = Z_RSHIFT((-0x0a8ab614LL * zoo1) + (-0x0019522eLL * zoo2) +
1010 (0x022cefc7LL * zoo3), 30);
1011 zoc4 = Z_RSHIFT((0x0276187dLL * zoe1) + (-0x03a801e8LL * zoe2) +
1012 (0x0131d935LL * zoe3), 30);
1013 zoc5 = Z_RSHIFT((0x02c373f5LL * zoo1) + (-0x01275f83LL * zoo2) +
1014 (0x0018ee79LL * zoo3), 30);
1016 coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT(
1017 (int64_t)zoc5 * zoz, Z_SHIFT) +
1018 zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) +
1019 zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0;
1021#error "Interpolation type screwed!"
1024#if Z_POLYPHASE_COEFF_SHIFT > 0
1033 int32_t alpha,
c, i, z, idx;
1044 if (((int64_t)info->
z_size * info->
z_gy * 2) >
1047 fprintf(stderr,
"Polyphase entries exceed: [%d/%d] %jd > %d\n",
1055 info->
z_pcoeff = malloc(
sizeof(int32_t) *
1056 info->
z_size * info->
z_gy * 2, M_DEVBUF, M_NOWAIT | M_ZERO);
1060 for (alpha = 0; alpha < info->
z_gy; alpha++) {
1061 z = alpha * info->
z_dx;
1063 for (i = info->
z_size; i != 0; i--) {
1066 idx = (alpha * info->
z_size * 2) +
1072 z = info->
z_dy - (alpha * info->
z_dx);
1074 for (i = info->
z_size; i != 0; i--) {
1077 idx = (alpha * info->
z_size * 2) + i - 1;
1085 fprintf(stderr,
"Polyphase: [%d/%d] %d entries\n",
1096 int64_t gy2gx_max, gx2gy_max;
1104 if (info->
src == info->
dst)
1160z_setup_adaptive_sinc:
1166 if (adaptive == 0) {
1172 info->
z_dy = Z_FULL_ONE;
1177#define Z_SCALE_DIV 10000
1178#define Z_SCALE_LIMIT(s, v) \
1179 ((((uint64_t)(s) * (v)) + (Z_SCALE_DIV >> 1)) / Z_SCALE_DIV)
1191 if (info->
z_dx < 1) {
1192 if (adaptive == 0) {
1194 goto z_setup_adaptive_sinc;
1204 for (i = 0; i < Z_COEFF_TAB_SIZE; i++) {
1222 if (adaptive == 0) {
1224 goto z_setup_adaptive_sinc;
1228 info->
z_coeff = z_coeff_tab[i].coeff + Z_COEFF_OFFSET;
1229 info->
z_dcoeff = z_coeff_tab[i].dcoeff;
1241 info->
z_dx = Z_LINEAR_FULL_ONE / info->
z_gy;
1279 gy2gx_max = (((uint64_t)info->
z_gy * INT32_MAX) - info->
z_gy + 1) /
1282 if ((gy2gx_max * align) > SND_FXDIV_MAX)
1283 gy2gx_max = SND_FXDIV_MAX / align;
1288 gx2gy_max = (((uint64_t)info->
z_gx * INT32_MAX) - info->
z_gy) /
1291 if (gx2gy_max > INT32_MAX)
1292 gx2gy_max = INT32_MAX;
1307#ifdef Z_USE_ALPHADRIFT
1318 if ((info->
z_full * align) < 1) {
1321 goto z_setup_adaptive_sinc;
1342 i = info->
z_full * align;
1350 info->
z_delay = malloc(i, M_DEVBUF, M_NOWAIT | M_ZERO);
1360 info->
z_pos * align);
1366#define dumpz(x) fprintf(stderr, "\t%12s = %10u : %-11d\n", \
1367 "z_"__STRING(x), (uint32_t)info->z_##x, \
1368 (int32_t)info->z_##x)
1369 fprintf(stderr,
"\n%s():\n", __func__);
1370 fprintf(stderr,
"\tchannels=%d, bps=%d, format=0x%08x, quality=%d\n",
1372 fprintf(stderr,
"\t%d (%d) -> %d (%d), ",
1374 fprintf(stderr,
"[%d/%d]\n", info->
z_gx, info->
z_gy);
1375 fprintf(stderr,
"\tminreq=%d, ",
z_gy2gx(info, 1));
1378 fprintf(stderr,
"factor=0x%08x/0x%08x (%f)\n",
1381 fprintf(stderr,
"adaptive=%s\n", (adaptive != 0) ?
"YES" :
"NO");
1385 fprintf(stderr,
"\t%15s%10d Bytes\n",
1387 else if (info->
z_alloc < (1024 << 10))
1388 fprintf(stderr,
"\t%15s%10d KBytes\n",
1390 else if (info->
z_alloc < (1024 << 20))
1391 fprintf(stderr,
"\t%15s%10d MBytes\n",
1394 fprintf(stderr,
"\t%15s%10d GBytes\n",
1396 fprintf(stderr,
"\t%12s %10d (min output samples)\n",
1399 fprintf(stderr,
"\t%12s %10d (min allocated output samples)\n",
1403 fprintf(stderr,
"\t%12s = %10d\n",
1404 "z_gy2gx()", (int32_t)
z_gy2gx(info, 1));
1405 fprintf(stderr,
"\t%12s = %10d -> z_gy2gx() -> %d\n",
1406 "Max", (int32_t)gy2gx_max, (int32_t)
z_gy2gx(info, gy2gx_max));
1407 fprintf(stderr,
"\t%12s = %10d\n",
1408 "z_gx2gy()", (int32_t)
z_gx2gy(info, 1));
1409 fprintf(stderr,
"\t%12s = %10d -> z_gx2gy() -> %d\n",
1410 "Max", (int32_t)gx2gy_max, (int32_t)
z_gx2gy(info, gx2gy_max));
1416 fprintf(stderr,
"\t%12s %10f\n",
"",
1417 (
double)info->
z_scale / Z_ONE);
1419 fprintf(stderr,
"\t%12s %10f\n",
"",
1422 fprintf(stderr,
"\t%12s %10d (drift step)\n",
"",
1423 info->
z_dy >> Z_SHIFT);
1424 fprintf(stderr,
"\t%12s %10d (scaling differences)\n",
"",
1426 fprintf(stderr,
"\t%12s = %u bytes\n",
1428 fprintf(stderr,
"\t%12s = 0x%08x, smallest=%.16lf\n",
1429 "Z_ONE", Z_ONE, (
double)1.0 / (
double)Z_ONE);
1459 if (value < Z_QUALITY_MIN || value > Z_QUALITY_MAX)
1499 return (info->
rsrc);
1502 return (info->
rdst);
1526 info = malloc(
sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO);
1543 free(info, M_DEVBUF);
1561 free(info, M_DEVBUF);
1574 int32_t alphadrift, startdrift, reqout, ocount, reqin, align;
1575 int32_t fetch, fetched,
start, cp;
1588 ocount = SND_FXDIV(
count, align);
1598#ifdef Z_USE_ALPHADRIFT
1603 alphadrift =
z_drift(info, startdrift, 1);
1619 (info->
z_size << 1) - 1);
1620 cp = (info->
z_size << 1) + fetched;
1630 static uint32_t kk = 0;
1633 "start=%d fetched=%d cp=%d "
1635 start, fetched, cp, info->z_cycle,
1648 fetch * align,
source), align);
1655 info->
z_pos += fetched;
1656 if (fetched != fetch)
1678 startdrift =
z_gy2gx(info, 1);
1679 alphadrift =
z_drift(info, startdrift, 1);
1687 info->
z_start += startdrift - 1;
1695 }
while (--reqout != 0);
1697 }
while (reqin != 0 && ocount != 0);
u_int8_t sndbuf_zerodata(u_int32_t fmt)
#define CHN_FOREACH(x, y, z)
struct pcm_feeder * chn_findfeeder(struct pcm_channel *c, u_int32_t type)
static __inline uint32_t z_min(uint32_t x, uint32_t y)
z_resampler_t resampler[Z_RESAMPLER_LAST]
static int z_resampler_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b, uint32_t count, void *source)
static int sysctl_hw_snd_feeder_rate_quality(SYSCTL_HANDLER_ARGS)
static struct pcm_feederdesc feeder_rate_desc[]
FEEDER_DECLARE(feeder_rate, NULL)
#define Z_SINC_COEFF_IDX(i)
static int z_resampler_setup(struct pcm_feeder *f)
void(* z_resampler_t)(struct z_info *, uint8_t *)
#define Z_RESAMPLER_IDX(i)
static int z_resampler_build_polyphase(struct z_info *info)
#define Z_QUALITY_DEFAULT
static int sysctl_hw_snd_feeder_rate_round(SYSCTL_HANDLER_ARGS)
#define Z_DECLARE(SIGN, BIT, ENDIAN)
static void z_feed_zoh(struct z_info *info, uint8_t *dst)
static int z_resampler_free(struct pcm_feeder *f)
static int feeder_rate_polyphase_max
static const struct @47 z_resampler_tab[]
SND_DECLARE_FILE("$FreeBSD$")
static char feeder_rate_presets[]
#define _Z_GY2GX(i, a, v)
static int32_t z_resampler_sinc_len(struct z_info *info)
@ Z_RESAMPLER_SINC_POLYPHASE
static kobj_method_t feeder_rate_methods[]
static uint32_t z_resampler_feed_internal(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b, uint32_t count, void *source)
static int sysctl_hw_snd_feeder_rate_min(SYSCTL_HANDLER_ARGS)
static void z_resampler_reset(struct z_info *info)
#define Z_POLYPHASE_COEFF_SHIFT
#define Z_RESAMPLER_ENTRY(SIGN, BIT, ENDIAN)
#define z_copy(src, dst, sz)
static int32_t z_coeff_interpolate(int32_t z, int32_t *z_coeff)
#define Z_SINC_BASE_LEN(i)
static int z_resampler_set(struct pcm_feeder *f, int what, int32_t value)
SYSCTL_STRING(_hw_snd, OID_AUTO, feeder_rate_presets, CTLFLAG_RD, &feeder_rate_presets, 0, "compile-time rate presets")
SYSCTL_INT(_hw_snd, OID_AUTO, feeder_rate_polyphase_max, CTLFLAG_RWTUN, &feeder_rate_polyphase_max, 0, "maximum allowable polyphase entries")
static int z_resampler_get(struct pcm_feeder *f, int what)
SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_min, CTLTYPE_INT|CTLFLAG_RWTUN|CTLFLAG_MPSAFE, 0, sizeof(int), sysctl_hw_snd_feeder_rate_min, "I", "minimum allowable rate")
static int32_t z_gcd(int32_t x, int32_t y)
static int32_t z_roundpow2(int32_t v)
static int sysctl_hw_snd_feeder_rate_max(SYSCTL_HANDLER_ARGS)
#define Z_RESAMPLER_TAB_SIZE
static int z_resampler_init(struct pcm_feeder *f)
#define PCM_REGISTERED(x)
struct pcm_feeder * source
struct pcm_feederdesc * desc
struct snddev_info::@49::@50 pcm