1139749Simp/*- 2193640Sariff * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org> 375320Scg * All rights reserved. 475320Scg * 575320Scg * Redistribution and use in source and binary forms, with or without 675320Scg * modification, are permitted provided that the following conditions 775320Scg * are met: 875320Scg * 1. Redistributions of source code must retain the above copyright 975320Scg * notice, this list of conditions and the following disclaimer. 1075320Scg * 2. Redistributions in binary form must reproduce the above copyright 1175320Scg * notice, this list of conditions and the following disclaimer in the 1275320Scg * documentation and/or other materials provided with the distribution. 1375320Scg * 1475320Scg * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1575320Scg * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1675320Scg * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1775320Scg * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 1875320Scg * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1975320Scg * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2075320Scg * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2175320Scg * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2275320Scg * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2375320Scg * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2475320Scg * SUCH DAMAGE. 25170206Sjoel */ 26170206Sjoel 27170206Sjoel/* 28193640Sariff * feeder_rate: (Codename: Z Resampler), which means any effort to create 29193640Sariff * future replacement for this resampler are simply absurd unless 30193640Sariff * the world decide to add new alphabet after Z. 31164614Sariff * 32193640Sariff * FreeBSD bandlimited sinc interpolator, technically based on 33193640Sariff * "Digital Audio Resampling" by Julius O. Smith III 34193640Sariff * - http://ccrma.stanford.edu/~jos/resample/ 35164614Sariff * 36193640Sariff * The Good: 37193640Sariff * + all out fixed point integer operations, no soft-float or anything like 38193640Sariff * that. 39193640Sariff * + classic polyphase converters with high quality coefficient's polynomial 40193640Sariff * interpolators. 41193640Sariff * + fast, faster, or the fastest of its kind. 42193640Sariff * + compile time configurable. 43193640Sariff * + etc etc.. 44109547Sorion * 45193640Sariff * The Bad: 46193640Sariff * - The z, z_, and Z_ . Due to mental block (or maybe just 0x7a69), I 47193640Sariff * couldn't think of anything simpler than that (feeder_rate_xxx is just 48193640Sariff * too long). Expect possible clashes with other zitizens (any?). 4975320Scg */ 5075320Scg 51193640Sariff#ifdef _KERNEL 52193640Sariff#ifdef HAVE_KERNEL_OPTION_HEADERS 53193640Sariff#include "opt_snd.h" 54193640Sariff#endif 5575320Scg#include <dev/sound/pcm/sound.h> 56193640Sariff#include <dev/sound/pcm/pcm.h> 5775320Scg#include "feeder_if.h" 5875320Scg 59193640Sariff#define SND_USE_FXDIV 60193640Sariff#include "snd_fxdiv_gen.h" 61193640Sariff 6282180ScgSND_DECLARE_FILE("$FreeBSD$"); 63193640Sariff#endif 64110466Sorion 65193640Sariff#include "feeder_rate_gen.h" 66110466Sorion 67193640Sariff#if !defined(_KERNEL) && defined(SND_DIAGNOSTIC) 68193640Sariff#undef Z_DIAGNOSTIC 69193640Sariff#define Z_DIAGNOSTIC 1 70193640Sariff#elif defined(_KERNEL) 71193640Sariff#undef Z_DIAGNOSTIC 72193640Sariff#endif 7375320Scg 74193640Sariff#ifndef Z_QUALITY_DEFAULT 75193640Sariff#define Z_QUALITY_DEFAULT Z_QUALITY_LINEAR 76193640Sariff#endif 77109547Sorion 78193640Sariff#define Z_RESERVOIR 2048 79193640Sariff#define Z_RESERVOIR_MAX 131072 80109547Sorion 81193640Sariff#define Z_SINC_MAX 0x3fffff 82193640Sariff#define Z_SINC_DOWNMAX 48 /* 384000 / 8000 */ 83110466Sorion 84193640Sariff#ifdef _KERNEL 85193640Sariff#define Z_POLYPHASE_MAX 183040 /* 286 taps, 640 phases */ 86193640Sariff#else 87193640Sariff#define Z_POLYPHASE_MAX 1464320 /* 286 taps, 5120 phases */ 88167646Sariff#endif 89193640Sariff 90193640Sariff#define Z_RATE_DEFAULT 48000 91193640Sariff 92193640Sariff#define Z_RATE_MIN FEEDRATE_RATEMIN 93193640Sariff#define Z_RATE_MAX FEEDRATE_RATEMAX 94193640Sariff#define Z_ROUNDHZ FEEDRATE_ROUNDHZ 95193640Sariff#define Z_ROUNDHZ_MIN FEEDRATE_ROUNDHZ_MIN 96193640Sariff#define Z_ROUNDHZ_MAX FEEDRATE_ROUNDHZ_MAX 97193640Sariff 98193640Sariff#define Z_RATE_SRC FEEDRATE_SRC 99193640Sariff#define Z_RATE_DST FEEDRATE_DST 100193640Sariff#define Z_RATE_QUALITY FEEDRATE_QUALITY 101193640Sariff#define Z_RATE_CHANNELS FEEDRATE_CHANNELS 102193640Sariff 103193640Sariff#define Z_PARANOID 1 104193640Sariff 105193640Sariff#define Z_MULTIFORMAT 1 106193640Sariff 107193640Sariff#ifdef _KERNEL 108193640Sariff#undef Z_USE_ALPHADRIFT 109193640Sariff#define Z_USE_ALPHADRIFT 1 110193640Sariff#endif 111193640Sariff 112193640Sariff#define Z_FACTOR_MIN 1 113193640Sariff#define Z_FACTOR_MAX Z_MASK 114193640Sariff#define Z_FACTOR_SAFE(v) (!((v) < Z_FACTOR_MIN || (v) > Z_FACTOR_MAX)) 115193640Sariff 116193640Sariffstruct z_info; 117193640Sariff 118193640Sarifftypedef void (*z_resampler_t)(struct z_info *, uint8_t *); 119193640Sariff 120193640Sariffstruct z_info { 121193640Sariff int32_t rsrc, rdst; /* original source / destination rates */ 122193640Sariff int32_t src, dst; /* rounded source / destination rates */ 123193640Sariff int32_t channels; /* total channels */ 124193640Sariff int32_t bps; /* bytes-per-sample */ 125193640Sariff int32_t quality; /* resampling quality */ 126193640Sariff 127193640Sariff int32_t z_gx, z_gy; /* interpolation / decimation ratio */ 128193640Sariff int32_t z_alpha; /* output sample time phase / drift */ 129193640Sariff uint8_t *z_delay; /* FIR delay line / linear buffer */ 130193640Sariff int32_t *z_coeff; /* FIR coefficients */ 131193640Sariff int32_t *z_dcoeff; /* FIR coefficients differences */ 132193640Sariff int32_t *z_pcoeff; /* FIR polyphase coefficients */ 133193640Sariff int32_t z_scale; /* output scaling */ 134193640Sariff int32_t z_dx; /* input sample drift increment */ 135193640Sariff int32_t z_dy; /* output sample drift increment */ 136193640Sariff#ifdef Z_USE_ALPHADRIFT 137193640Sariff int32_t z_alphadrift; /* alpha drift rate */ 138193640Sariff int32_t z_startdrift; /* buffer start position drift rate */ 139193640Sariff#endif 140193640Sariff int32_t z_mask; /* delay line full length mask */ 141193640Sariff int32_t z_size; /* half width of FIR taps */ 142193640Sariff int32_t z_full; /* full size of delay line */ 143193640Sariff int32_t z_alloc; /* largest allocated full size of delay line */ 144193640Sariff int32_t z_start; /* buffer processing start position */ 145193640Sariff int32_t z_pos; /* current position for the next feed */ 146193640Sariff#ifdef Z_DIAGNOSTIC 147193640Sariff uint32_t z_cycle; /* output cycle, purely for statistical */ 148193640Sariff#endif 149193640Sariff int32_t z_maxfeed; /* maximum feed to avoid 32bit overflow */ 150193640Sariff 151193640Sariff z_resampler_t z_resample; 152148606Snetchild}; 153148606Snetchild 154193640Sariffint feeder_rate_min = Z_RATE_MIN; 155193640Sariffint feeder_rate_max = Z_RATE_MAX; 156193640Sariffint feeder_rate_round = Z_ROUNDHZ; 157193640Sariffint feeder_rate_quality = Z_QUALITY_DEFAULT; 158148606Snetchild 159193640Sariffstatic int feeder_rate_polyphase_max = Z_POLYPHASE_MAX; 160193640Sariff 161193640Sariff#ifdef _KERNEL 162209193Savgstatic char feeder_rate_presets[] = FEEDER_RATE_PRESETS; 163193640SariffSYSCTL_STRING(_hw_snd, OID_AUTO, feeder_rate_presets, CTLFLAG_RD, 164193640Sariff &feeder_rate_presets, 0, "compile-time rate presets"); 165267992ShselaskySYSCTL_INT(_hw_snd, OID_AUTO, feeder_rate_polyphase_max, CTLFLAG_RWTUN, 166193640Sariff &feeder_rate_polyphase_max, 0, "maximum allowable polyphase entries"); 167193640Sariff 168148606Snetchildstatic int 169164614Sariffsysctl_hw_snd_feeder_rate_min(SYSCTL_HANDLER_ARGS) 170148606Snetchild{ 171148606Snetchild int err, val; 172109547Sorion 173164614Sariff val = feeder_rate_min; 174170289Sdwmalone err = sysctl_handle_int(oidp, &val, 0, req); 175193640Sariff 176193640Sariff if (err != 0 || req->newptr == NULL || val == feeder_rate_min) 177167646Sariff return (err); 178193640Sariff 179193640Sariff if (!(Z_FACTOR_SAFE(val) && val < feeder_rate_max)) 180193640Sariff return (EINVAL); 181193640Sariff 182193640Sariff feeder_rate_min = val; 183193640Sariff 184193640Sariff return (0); 185148606Snetchild} 186280442ShselaskySYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_min, CTLTYPE_INT | CTLFLAG_RWTUN, 187193640Sariff 0, sizeof(int), sysctl_hw_snd_feeder_rate_min, "I", 188193640Sariff "minimum allowable rate"); 189109547Sorion 190148606Snetchildstatic int 191164614Sariffsysctl_hw_snd_feeder_rate_max(SYSCTL_HANDLER_ARGS) 192148606Snetchild{ 193148606Snetchild int err, val; 194109547Sorion 195164614Sariff val = feeder_rate_max; 196170289Sdwmalone err = sysctl_handle_int(oidp, &val, 0, req); 197193640Sariff 198193640Sariff if (err != 0 || req->newptr == NULL || val == feeder_rate_max) 199167646Sariff return (err); 200193640Sariff 201193640Sariff if (!(Z_FACTOR_SAFE(val) && val > feeder_rate_min)) 202193640Sariff return (EINVAL); 203193640Sariff 204193640Sariff feeder_rate_max = val; 205193640Sariff 206193640Sariff return (0); 207148606Snetchild} 208280442ShselaskySYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_max, CTLTYPE_INT | CTLFLAG_RWTUN, 209193640Sariff 0, sizeof(int), sysctl_hw_snd_feeder_rate_max, "I", 210193640Sariff "maximum allowable rate"); 211148606Snetchild 212109547Sorionstatic int 213164614Sariffsysctl_hw_snd_feeder_rate_round(SYSCTL_HANDLER_ARGS) 214148606Snetchild{ 215148606Snetchild int err, val; 216109547Sorion 217164614Sariff val = feeder_rate_round; 218170289Sdwmalone err = sysctl_handle_int(oidp, &val, 0, req); 219193640Sariff 220193640Sariff if (err != 0 || req->newptr == NULL || val == feeder_rate_round) 221167646Sariff return (err); 222193640Sariff 223193640Sariff if (val < Z_ROUNDHZ_MIN || val > Z_ROUNDHZ_MAX) 224193640Sariff return (EINVAL); 225193640Sariff 226193640Sariff feeder_rate_round = val - (val % Z_ROUNDHZ); 227193640Sariff 228193640Sariff return (0); 229148606Snetchild} 230280442ShselaskySYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_round, CTLTYPE_INT | CTLFLAG_RWTUN, 231193640Sariff 0, sizeof(int), sysctl_hw_snd_feeder_rate_round, "I", 232193640Sariff "sample rate converter rounding threshold"); 233109547Sorion 234193640Sariffstatic int 235193640Sariffsysctl_hw_snd_feeder_rate_quality(SYSCTL_HANDLER_ARGS) 236193640Sariff{ 237193640Sariff struct snddev_info *d; 238193640Sariff struct pcm_channel *c; 239193640Sariff struct pcm_feeder *f; 240193640Sariff int i, err, val; 241193640Sariff 242193640Sariff val = feeder_rate_quality; 243193640Sariff err = sysctl_handle_int(oidp, &val, 0, req); 244193640Sariff 245193640Sariff if (err != 0 || req->newptr == NULL || val == feeder_rate_quality) 246193640Sariff return (err); 247193640Sariff 248193640Sariff if (val < Z_QUALITY_MIN || val > Z_QUALITY_MAX) 249193640Sariff return (EINVAL); 250193640Sariff 251193640Sariff feeder_rate_quality = val; 252193640Sariff 253193640Sariff /* 254193640Sariff * Traverse all available channels on each device and try to 255193640Sariff * set resampler quality if and only if it is exist as 256193640Sariff * part of feeder chains and the channel is idle. 257193640Sariff */ 258193640Sariff for (i = 0; pcm_devclass != NULL && 259193640Sariff i < devclass_get_maxunit(pcm_devclass); i++) { 260193640Sariff d = devclass_get_softc(pcm_devclass, i); 261193640Sariff if (!PCM_REGISTERED(d)) 262193640Sariff continue; 263193640Sariff PCM_LOCK(d); 264193640Sariff PCM_WAIT(d); 265193640Sariff PCM_ACQUIRE(d); 266193640Sariff CHN_FOREACH(c, d, channels.pcm) { 267193640Sariff CHN_LOCK(c); 268193640Sariff f = chn_findfeeder(c, FEEDER_RATE); 269193640Sariff if (f == NULL || f->data == NULL || CHN_STARTED(c)) { 270193640Sariff CHN_UNLOCK(c); 271193640Sariff continue; 272193640Sariff } 273193640Sariff (void)FEEDER_SET(f, FEEDRATE_QUALITY, val); 274193640Sariff CHN_UNLOCK(c); 275193640Sariff } 276193640Sariff PCM_RELEASE(d); 277193640Sariff PCM_UNLOCK(d); 278193640Sariff } 279193640Sariff 280193640Sariff return (0); 281148606Snetchild} 282280442ShselaskySYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_quality, CTLTYPE_INT | CTLFLAG_RWTUN, 283193640Sariff 0, sizeof(int), sysctl_hw_snd_feeder_rate_quality, "I", 284193640Sariff "sample rate converter quality ("__XSTRING(Z_QUALITY_MIN)"=low .. " 285193640Sariff __XSTRING(Z_QUALITY_MAX)"=high)"); 286193640Sariff#endif /* _KERNEL */ 287109547Sorion 288164614Sariff 289193640Sariff/* 290193640Sariff * Resampler type. 291193640Sariff */ 292193640Sariff#define Z_IS_ZOH(i) ((i)->quality == Z_QUALITY_ZOH) 293193640Sariff#define Z_IS_LINEAR(i) ((i)->quality == Z_QUALITY_LINEAR) 294193640Sariff#define Z_IS_SINC(i) ((i)->quality > Z_QUALITY_LINEAR) 295193640Sariff 296193640Sariff/* 297193640Sariff * Macroses for accurate sample time drift calculations. 298193640Sariff * 299193640Sariff * gy2gx : given the amount of output, return the _exact_ required amount of 300193640Sariff * input. 301193640Sariff * gx2gy : given the amount of input, return the _maximum_ amount of output 302193640Sariff * that will be generated. 303193640Sariff * drift : given the amount of input and output, return the elapsed 304193640Sariff * sample-time. 305193640Sariff */ 306193640Sariff#define _Z_GCAST(x) ((uint64_t)(x)) 307193640Sariff 308193640Sariff#if defined(__GNUCLIKE_ASM) && defined(__i386__) 309193640Sariff/* 310193640Sariff * This is where i386 being beaten to a pulp. Fortunately this function is 311193640Sariff * rarely being called and if it is, it will decide the best (hopefully) 312193640Sariff * fastest way to do the division. If we can ensure that everything is dword 313193640Sariff * aligned, letting the compiler to call udivdi3 to do the division can be 314193640Sariff * faster compared to this. 315193640Sariff * 316193640Sariff * amd64 is the clear winner here, no question about it. 317193640Sariff */ 318193640Sariffstatic __inline uint32_t 319193640SariffZ_DIV(uint64_t v, uint32_t d) 320109547Sorion{ 321193640Sariff uint32_t hi, lo, quo, rem; 322148606Snetchild 323193640Sariff hi = v >> 32; 324193640Sariff lo = v & 0xffffffff; 325193640Sariff 326193640Sariff /* 327193640Sariff * As much as we can, try to avoid long division like a plague. 328193640Sariff */ 329193640Sariff if (hi == 0) 330193640Sariff quo = lo / d; 331193640Sariff else 332193640Sariff __asm("divl %2" 333193640Sariff : "=a" (quo), "=d" (rem) 334193640Sariff : "r" (d), "0" (lo), "1" (hi)); 335193640Sariff 336193640Sariff return (quo); 337193640Sariff} 338193640Sariff#else 339193640Sariff#define Z_DIV(x, y) ((x) / (y)) 340193640Sariff#endif 341193640Sariff 342193640Sariff#define _Z_GY2GX(i, a, v) \ 343193640Sariff Z_DIV(((_Z_GCAST((i)->z_gx) * (v)) + ((i)->z_gy - (a) - 1)), \ 344193640Sariff (i)->z_gy) 345193640Sariff 346193640Sariff#define _Z_GX2GY(i, a, v) \ 347193640Sariff Z_DIV(((_Z_GCAST((i)->z_gy) * (v)) + (a)), (i)->z_gx) 348193640Sariff 349193640Sariff#define _Z_DRIFT(i, x, y) \ 350193640Sariff ((_Z_GCAST((i)->z_gy) * (x)) - (_Z_GCAST((i)->z_gx) * (y))) 351193640Sariff 352193640Sariff#define z_gy2gx(i, v) _Z_GY2GX(i, (i)->z_alpha, v) 353193640Sariff#define z_gx2gy(i, v) _Z_GX2GY(i, (i)->z_alpha, v) 354193640Sariff#define z_drift(i, x, y) _Z_DRIFT(i, x, y) 355193640Sariff 356193640Sariff/* 357193640Sariff * Macroses for SINC coefficients table manipulations.. whatever. 358193640Sariff */ 359193640Sariff#define Z_SINC_COEFF_IDX(i) ((i)->quality - Z_QUALITY_LINEAR - 1) 360193640Sariff 361193640Sariff#define Z_SINC_LEN(i) \ 362193640Sariff ((int32_t)(((uint64_t)z_coeff_tab[Z_SINC_COEFF_IDX(i)].len << \ 363193640Sariff Z_SHIFT) / (i)->z_dy)) 364193640Sariff 365193640Sariff#define Z_SINC_BASE_LEN(i) \ 366193640Sariff ((z_coeff_tab[Z_SINC_COEFF_IDX(i)].len - 1) >> (Z_DRIFT_SHIFT - 1)) 367193640Sariff 368193640Sariff/* 369193640Sariff * Macroses for linear delay buffer operations. Alignment is not 370193640Sariff * really necessary since we're not using true circular buffer, but it 371193640Sariff * will help us guard against possible trespasser. To be honest, 372193640Sariff * the linear block operations does not need guarding at all due to 373193640Sariff * accurate drifting! 374193640Sariff */ 375193640Sariff#define z_align(i, v) ((v) & (i)->z_mask) 376193640Sariff#define z_next(i, o, v) z_align(i, (o) + (v)) 377193640Sariff#define z_prev(i, o, v) z_align(i, (o) - (v)) 378193640Sariff#define z_fetched(i) (z_align(i, (i)->z_pos - (i)->z_start) - 1) 379193640Sariff#define z_free(i) ((i)->z_full - (i)->z_pos) 380193640Sariff 381193640Sariff/* 382193640Sariff * Macroses for Bla Bla .. :) 383193640Sariff */ 384193640Sariff#define z_copy(src, dst, sz) (void)memcpy(dst, src, sz) 385193640Sariff#define z_feed(...) FEEDER_FEED(__VA_ARGS__) 386193640Sariff 387193640Sariffstatic __inline uint32_t 388193640Sariffz_min(uint32_t x, uint32_t y) 389193640Sariff{ 390193640Sariff 391193640Sariff return ((x < y) ? x : y); 392193640Sariff} 393193640Sariff 394193640Sariffstatic int32_t 395193640Sariffz_gcd(int32_t x, int32_t y) 396193640Sariff{ 397193640Sariff int32_t w; 398193640Sariff 399110108Sorion while (y != 0) { 400110108Sorion w = x % y; 401110108Sorion x = y; 402110108Sorion y = w; 403110108Sorion } 404193640Sariff 405193640Sariff return (x); 406109547Sorion} 407109547Sorion 408193640Sariffstatic int32_t 409193640Sariffz_roundpow2(int32_t v) 410193640Sariff{ 411193640Sariff int32_t i; 412193640Sariff 413193640Sariff i = 1; 414193640Sariff 415193640Sariff /* 416193640Sariff * Let it overflow at will.. 417193640Sariff */ 418193640Sariff while (i > 0 && i < v) 419193640Sariff i <<= 1; 420193640Sariff 421193640Sariff return (i); 422193640Sariff} 423193640Sariff 424193640Sariff/* 425193640Sariff * Zero Order Hold, the worst of the worst, an insult against quality, 426193640Sariff * but super fast. 427193640Sariff */ 428148606Snetchildstatic void 429193640Sariffz_feed_zoh(struct z_info *info, uint8_t *dst) 430148606Snetchild{ 431193640Sariff#if 0 432193640Sariff z_copy(info->z_delay + 433193640Sariff (info->z_start * info->channels * info->bps), dst, 434193640Sariff info->channels * info->bps); 435193640Sariff#else 436193640Sariff uint32_t cnt; 437193640Sariff uint8_t *src; 438193640Sariff 439193640Sariff cnt = info->channels * info->bps; 440193640Sariff src = info->z_delay + (info->z_start * cnt); 441193640Sariff 442193640Sariff /* 443193640Sariff * This is a bit faster than doing bcopy() since we're dealing 444193640Sariff * with possible unaligned samples. 445193640Sariff */ 446193640Sariff do { 447193640Sariff *dst++ = *src++; 448193640Sariff } while (--cnt != 0); 449167646Sariff#endif 450148606Snetchild} 451148606Snetchild 452193640Sariff/* 453193640Sariff * Linear Interpolation. This at least sounds better (perceptually) and fast, 454193640Sariff * but without any proper filtering which means aliasing still exist and 455193640Sariff * could become worst with a right sample. Interpolation centered within 456193640Sariff * Z_LINEAR_ONE between the present and previous sample and everything is 457193640Sariff * done with simple 32bit scaling arithmetic. 458193640Sariff */ 459193640Sariff#define Z_DECLARE_LINEAR(SIGN, BIT, ENDIAN) \ 460193640Sariffstatic void \ 461193640Sariffz_feed_linear_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \ 462193640Sariff{ \ 463193640Sariff int32_t z; \ 464193640Sariff intpcm_t x, y; \ 465193640Sariff uint32_t ch; \ 466193640Sariff uint8_t *sx, *sy; \ 467193640Sariff \ 468193640Sariff z = ((uint32_t)info->z_alpha * info->z_dx) >> Z_LINEAR_UNSHIFT; \ 469193640Sariff \ 470193640Sariff sx = info->z_delay + (info->z_start * info->channels * \ 471193640Sariff PCM_##BIT##_BPS); \ 472193640Sariff sy = sx - (info->channels * PCM_##BIT##_BPS); \ 473193640Sariff \ 474193640Sariff ch = info->channels; \ 475193640Sariff \ 476193640Sariff do { \ 477193640Sariff x = _PCM_READ_##SIGN##BIT##_##ENDIAN(sx); \ 478193640Sariff y = _PCM_READ_##SIGN##BIT##_##ENDIAN(sy); \ 479193640Sariff x = Z_LINEAR_INTERPOLATE_##BIT(z, x, y); \ 480193640Sariff _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x); \ 481193640Sariff sx += PCM_##BIT##_BPS; \ 482193640Sariff sy += PCM_##BIT##_BPS; \ 483193640Sariff dst += PCM_##BIT##_BPS; \ 484193640Sariff } while (--ch != 0); \ 485193640Sariff} 486193640Sariff 487193640Sariff/* 488193640Sariff * Userland clipping diagnostic check, not enabled in kernel compilation. 489193640Sariff * While doing sinc interpolation, unrealistic samples like full scale sine 490193640Sariff * wav will clip, but for other things this will not make any noise at all. 491193640Sariff * Everybody should learn how to normalized perceived loudness of their own 492193640Sariff * music/sounds/samples (hint: ReplayGain). 493193640Sariff */ 494193640Sariff#ifdef Z_DIAGNOSTIC 495193640Sariff#define Z_CLIP_CHECK(v, BIT) do { \ 496193640Sariff if ((v) > PCM_S##BIT##_MAX) { \ 497193640Sariff fprintf(stderr, "Overflow: v=%jd, max=%jd\n", \ 498193640Sariff (intmax_t)(v), (intmax_t)PCM_S##BIT##_MAX); \ 499193640Sariff } else if ((v) < PCM_S##BIT##_MIN) { \ 500193640Sariff fprintf(stderr, "Underflow: v=%jd, min=%jd\n", \ 501193640Sariff (intmax_t)(v), (intmax_t)PCM_S##BIT##_MIN); \ 502193640Sariff } \ 503193640Sariff} while (0) 504193640Sariff#else 505193640Sariff#define Z_CLIP_CHECK(...) 506193640Sariff#endif 507193640Sariff 508193640Sariff#define Z_CLAMP(v, BIT) \ 509193640Sariff (((v) > PCM_S##BIT##_MAX) ? PCM_S##BIT##_MAX : \ 510193640Sariff (((v) < PCM_S##BIT##_MIN) ? PCM_S##BIT##_MIN : (v))) 511193640Sariff 512193640Sariff/* 513193640Sariff * Sine Cardinal (SINC) Interpolation. Scaling is done in 64 bit, so 514193640Sariff * there's no point to hold the plate any longer. All samples will be 515193640Sariff * shifted to a full 32 bit, scaled and restored during write for 516193640Sariff * maximum dynamic range (only for downsampling). 517193640Sariff */ 518193640Sariff#define _Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, adv) \ 519193640Sariff c += z >> Z_SHIFT; \ 520193640Sariff z &= Z_MASK; \ 521193640Sariff coeff = Z_COEFF_INTERPOLATE(z, z_coeff[c], z_dcoeff[c]); \ 522193640Sariff x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \ 523195378Sariff v += Z_NORM_##BIT((intpcm64_t)x * coeff); \ 524193640Sariff z += info->z_dy; \ 525193640Sariff p adv##= info->channels * PCM_##BIT##_BPS 526193640Sariff 527193640Sariff/* 528193640Sariff * XXX GCC4 optimization is such a !@#$%, need manual unrolling. 529193640Sariff */ 530193640Sariff#if defined(__GNUC__) && __GNUC__ >= 4 531193640Sariff#define Z_SINC_ACCUMULATE(...) do { \ 532193640Sariff _Z_SINC_ACCUMULATE(__VA_ARGS__); \ 533193640Sariff _Z_SINC_ACCUMULATE(__VA_ARGS__); \ 534193640Sariff} while (0) 535193640Sariff#define Z_SINC_ACCUMULATE_DECR 2 536193640Sariff#else 537193640Sariff#define Z_SINC_ACCUMULATE(...) do { \ 538193640Sariff _Z_SINC_ACCUMULATE(__VA_ARGS__); \ 539193640Sariff} while (0) 540193640Sariff#define Z_SINC_ACCUMULATE_DECR 1 541193640Sariff#endif 542193640Sariff 543193640Sariff#define Z_DECLARE_SINC(SIGN, BIT, ENDIAN) \ 544193640Sariffstatic void \ 545193640Sariffz_feed_sinc_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \ 546193640Sariff{ \ 547193640Sariff intpcm64_t v; \ 548193640Sariff intpcm_t x; \ 549193640Sariff uint8_t *p; \ 550193640Sariff int32_t coeff, z, *z_coeff, *z_dcoeff; \ 551193640Sariff uint32_t c, center, ch, i; \ 552193640Sariff \ 553193640Sariff z_coeff = info->z_coeff; \ 554193640Sariff z_dcoeff = info->z_dcoeff; \ 555193640Sariff center = z_prev(info, info->z_start, info->z_size); \ 556193640Sariff ch = info->channels * PCM_##BIT##_BPS; \ 557193640Sariff dst += ch; \ 558193640Sariff \ 559193640Sariff do { \ 560193640Sariff dst -= PCM_##BIT##_BPS; \ 561193640Sariff ch -= PCM_##BIT##_BPS; \ 562193640Sariff v = 0; \ 563193640Sariff z = info->z_alpha * info->z_dx; \ 564193640Sariff c = 0; \ 565193640Sariff p = info->z_delay + (z_next(info, center, 1) * \ 566193640Sariff info->channels * PCM_##BIT##_BPS) + ch; \ 567193640Sariff for (i = info->z_size; i != 0; i -= Z_SINC_ACCUMULATE_DECR) \ 568193640Sariff Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, +); \ 569193640Sariff z = info->z_dy - (info->z_alpha * info->z_dx); \ 570193640Sariff c = 0; \ 571193640Sariff p = info->z_delay + (center * info->channels * \ 572193640Sariff PCM_##BIT##_BPS) + ch; \ 573193640Sariff for (i = info->z_size; i != 0; i -= Z_SINC_ACCUMULATE_DECR) \ 574193640Sariff Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, -); \ 575193640Sariff if (info->z_scale != Z_ONE) \ 576193640Sariff v = Z_SCALE_##BIT(v, info->z_scale); \ 577193640Sariff else \ 578195378Sariff v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \ 579193640Sariff Z_CLIP_CHECK(v, BIT); \ 580193640Sariff _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \ 581193640Sariff } while (ch != 0); \ 582193640Sariff} 583193640Sariff 584193640Sariff#define Z_DECLARE_SINC_POLYPHASE(SIGN, BIT, ENDIAN) \ 585193640Sariffstatic void \ 586193640Sariffz_feed_sinc_polyphase_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \ 587193640Sariff{ \ 588193640Sariff intpcm64_t v; \ 589193640Sariff intpcm_t x; \ 590193640Sariff uint8_t *p; \ 591193640Sariff int32_t ch, i, start, *z_pcoeff; \ 592193640Sariff \ 593193640Sariff ch = info->channels * PCM_##BIT##_BPS; \ 594193640Sariff dst += ch; \ 595193640Sariff start = z_prev(info, info->z_start, (info->z_size << 1) - 1) * ch; \ 596193640Sariff \ 597193640Sariff do { \ 598193640Sariff dst -= PCM_##BIT##_BPS; \ 599193640Sariff ch -= PCM_##BIT##_BPS; \ 600193640Sariff v = 0; \ 601193640Sariff p = info->z_delay + start + ch; \ 602193640Sariff z_pcoeff = info->z_pcoeff + \ 603193640Sariff ((info->z_alpha * info->z_size) << 1); \ 604193640Sariff for (i = info->z_size; i != 0; i--) { \ 605193640Sariff x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \ 606195378Sariff v += Z_NORM_##BIT((intpcm64_t)x * *z_pcoeff); \ 607193640Sariff z_pcoeff++; \ 608193640Sariff p += info->channels * PCM_##BIT##_BPS; \ 609193640Sariff x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \ 610195378Sariff v += Z_NORM_##BIT((intpcm64_t)x * *z_pcoeff); \ 611193640Sariff z_pcoeff++; \ 612193640Sariff p += info->channels * PCM_##BIT##_BPS; \ 613193640Sariff } \ 614193640Sariff if (info->z_scale != Z_ONE) \ 615193640Sariff v = Z_SCALE_##BIT(v, info->z_scale); \ 616193640Sariff else \ 617195378Sariff v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \ 618193640Sariff Z_CLIP_CHECK(v, BIT); \ 619193640Sariff _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \ 620193640Sariff } while (ch != 0); \ 621193640Sariff} 622193640Sariff 623193640Sariff#define Z_DECLARE(SIGN, BIT, ENDIAN) \ 624193640Sariff Z_DECLARE_LINEAR(SIGN, BIT, ENDIAN) \ 625193640Sariff Z_DECLARE_SINC(SIGN, BIT, ENDIAN) \ 626193640Sariff Z_DECLARE_SINC_POLYPHASE(SIGN, BIT, ENDIAN) 627193640Sariff 628193640Sariff#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 629193640SariffZ_DECLARE(S, 16, LE) 630193640SariffZ_DECLARE(S, 32, LE) 631193640Sariff#endif 632193640Sariff#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 633193640SariffZ_DECLARE(S, 16, BE) 634193640SariffZ_DECLARE(S, 32, BE) 635193640Sariff#endif 636193640Sariff#ifdef SND_FEEDER_MULTIFORMAT 637193640SariffZ_DECLARE(S, 8, NE) 638193640SariffZ_DECLARE(S, 24, LE) 639193640SariffZ_DECLARE(S, 24, BE) 640193640SariffZ_DECLARE(U, 8, NE) 641193640SariffZ_DECLARE(U, 16, LE) 642193640SariffZ_DECLARE(U, 24, LE) 643193640SariffZ_DECLARE(U, 32, LE) 644193640SariffZ_DECLARE(U, 16, BE) 645193640SariffZ_DECLARE(U, 24, BE) 646193640SariffZ_DECLARE(U, 32, BE) 647193640Sariff#endif 648193640Sariff 649193640Sariffenum { 650193640Sariff Z_RESAMPLER_ZOH, 651193640Sariff Z_RESAMPLER_LINEAR, 652193640Sariff Z_RESAMPLER_SINC, 653193640Sariff Z_RESAMPLER_SINC_POLYPHASE, 654193640Sariff Z_RESAMPLER_LAST 655193640Sariff}; 656193640Sariff 657193640Sariff#define Z_RESAMPLER_IDX(i) \ 658193640Sariff (Z_IS_SINC(i) ? Z_RESAMPLER_SINC : (i)->quality) 659193640Sariff 660193640Sariff#define Z_RESAMPLER_ENTRY(SIGN, BIT, ENDIAN) \ 661193640Sariff { \ 662193640Sariff AFMT_##SIGN##BIT##_##ENDIAN, \ 663193640Sariff { \ 664193640Sariff [Z_RESAMPLER_ZOH] = z_feed_zoh, \ 665193640Sariff [Z_RESAMPLER_LINEAR] = z_feed_linear_##SIGN##BIT##ENDIAN, \ 666193640Sariff [Z_RESAMPLER_SINC] = z_feed_sinc_##SIGN##BIT##ENDIAN, \ 667193640Sariff [Z_RESAMPLER_SINC_POLYPHASE] = \ 668193640Sariff z_feed_sinc_polyphase_##SIGN##BIT##ENDIAN \ 669193640Sariff } \ 670193640Sariff } 671193640Sariff 672193640Sariffstatic const struct { 673193640Sariff uint32_t format; 674193640Sariff z_resampler_t resampler[Z_RESAMPLER_LAST]; 675193640Sariff} z_resampler_tab[] = { 676193640Sariff#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 677193640Sariff Z_RESAMPLER_ENTRY(S, 16, LE), 678193640Sariff Z_RESAMPLER_ENTRY(S, 32, LE), 679193640Sariff#endif 680193640Sariff#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 681193640Sariff Z_RESAMPLER_ENTRY(S, 16, BE), 682193640Sariff Z_RESAMPLER_ENTRY(S, 32, BE), 683193640Sariff#endif 684193640Sariff#ifdef SND_FEEDER_MULTIFORMAT 685193640Sariff Z_RESAMPLER_ENTRY(S, 8, NE), 686193640Sariff Z_RESAMPLER_ENTRY(S, 24, LE), 687193640Sariff Z_RESAMPLER_ENTRY(S, 24, BE), 688193640Sariff Z_RESAMPLER_ENTRY(U, 8, NE), 689193640Sariff Z_RESAMPLER_ENTRY(U, 16, LE), 690193640Sariff Z_RESAMPLER_ENTRY(U, 24, LE), 691193640Sariff Z_RESAMPLER_ENTRY(U, 32, LE), 692193640Sariff Z_RESAMPLER_ENTRY(U, 16, BE), 693193640Sariff Z_RESAMPLER_ENTRY(U, 24, BE), 694193640Sariff Z_RESAMPLER_ENTRY(U, 32, BE), 695193640Sariff#endif 696193640Sariff}; 697193640Sariff 698193640Sariff#define Z_RESAMPLER_TAB_SIZE \ 699193640Sariff ((int32_t)(sizeof(z_resampler_tab) / sizeof(z_resampler_tab[0]))) 700193640Sariff 701193640Sariffstatic void 702193640Sariffz_resampler_reset(struct z_info *info) 70375320Scg{ 70475320Scg 705193640Sariff info->src = info->rsrc - (info->rsrc % ((feeder_rate_round > 0 && 706193640Sariff info->rsrc > feeder_rate_round) ? feeder_rate_round : 1)); 707193640Sariff info->dst = info->rdst - (info->rdst % ((feeder_rate_round > 0 && 708193640Sariff info->rdst > feeder_rate_round) ? feeder_rate_round : 1)); 709193640Sariff info->z_gx = 1; 710193640Sariff info->z_gy = 1; 711193640Sariff info->z_alpha = 0; 712193640Sariff info->z_resample = NULL; 713193640Sariff info->z_size = 1; 714193640Sariff info->z_coeff = NULL; 715193640Sariff info->z_dcoeff = NULL; 716193640Sariff if (info->z_pcoeff != NULL) { 717193640Sariff free(info->z_pcoeff, M_DEVBUF); 718193640Sariff info->z_pcoeff = NULL; 719193640Sariff } 720193640Sariff info->z_scale = Z_ONE; 721193640Sariff info->z_dx = Z_FULL_ONE; 722193640Sariff info->z_dy = Z_FULL_ONE; 723193640Sariff#ifdef Z_DIAGNOSTIC 724193640Sariff info->z_cycle = 0; 725193640Sariff#endif 726193640Sariff if (info->quality < Z_QUALITY_MIN) 727193640Sariff info->quality = Z_QUALITY_MIN; 728193640Sariff else if (info->quality > Z_QUALITY_MAX) 729193640Sariff info->quality = Z_QUALITY_MAX; 730193640Sariff} 731164614Sariff 732193640Sariff#ifdef Z_PARANOID 733193640Sariffstatic int32_t 734193640Sariffz_resampler_sinc_len(struct z_info *info) 735193640Sariff{ 736193640Sariff int32_t c, z, len, lmax; 737164614Sariff 738193640Sariff if (!Z_IS_SINC(info)) 739193640Sariff return (1); 740193640Sariff 741193640Sariff /* 742193640Sariff * A rather careful (or useless) way to calculate filter length. 743193640Sariff * Z_SINC_LEN() itself is accurate enough to do its job. Extra 744193640Sariff * sanity checking is not going to hurt though.. 745193640Sariff */ 746193640Sariff c = 0; 747193640Sariff z = info->z_dy; 748193640Sariff len = 0; 749193640Sariff lmax = z_coeff_tab[Z_SINC_COEFF_IDX(info)].len; 750193640Sariff 751193640Sariff do { 752193640Sariff c += z >> Z_SHIFT; 753193640Sariff z &= Z_MASK; 754193640Sariff z += info->z_dy; 755193640Sariff } while (c < lmax && ++len > 0); 756193640Sariff 757193640Sariff if (len != Z_SINC_LEN(info)) { 758193640Sariff#ifdef _KERNEL 759193640Sariff printf("%s(): sinc l=%d != Z_SINC_LEN=%d\n", 760193640Sariff __func__, len, Z_SINC_LEN(info)); 761193640Sariff#else 762193640Sariff fprintf(stderr, "%s(): sinc l=%d != Z_SINC_LEN=%d\n", 763193640Sariff __func__, len, Z_SINC_LEN(info)); 764167646Sariff return (-1); 765193640Sariff#endif 766193640Sariff } 767164614Sariff 768193640Sariff return (len); 769193640Sariff} 770193640Sariff#else 771193640Sariff#define z_resampler_sinc_len(i) (Z_IS_SINC(i) ? Z_SINC_LEN(i) : 1) 772193640Sariff#endif 773193640Sariff 774193640Sariff#define Z_POLYPHASE_COEFF_SHIFT 0 775193640Sariff 776193640Sariff/* 777193640Sariff * Pick suitable polynomial interpolators based on filter oversampled ratio 778193640Sariff * (2 ^ Z_DRIFT_SHIFT). 779193640Sariff */ 780193640Sariff#if !(defined(Z_COEFF_INTERP_ZOH) || defined(Z_COEFF_INTERP_LINEAR) || \ 781193640Sariff defined(Z_COEFF_INTERP_QUADRATIC) || defined(Z_COEFF_INTERP_HERMITE) || \ 782193640Sariff defined(Z_COEFF_INTER_BSPLINE) || defined(Z_COEFF_INTERP_OPT32X) || \ 783193640Sariff defined(Z_COEFF_INTERP_OPT16X) || defined(Z_COEFF_INTERP_OPT8X) || \ 784193640Sariff defined(Z_COEFF_INTERP_OPT4X) || defined(Z_COEFF_INTERP_OPT2X)) 785195689Sariff#if Z_DRIFT_SHIFT >= 6 786195689Sariff#define Z_COEFF_INTERP_BSPLINE 1 787194232Sariff#elif Z_DRIFT_SHIFT >= 5 788193640Sariff#define Z_COEFF_INTERP_OPT32X 1 789193640Sariff#elif Z_DRIFT_SHIFT == 4 790193640Sariff#define Z_COEFF_INTERP_OPT16X 1 791193640Sariff#elif Z_DRIFT_SHIFT == 3 792193640Sariff#define Z_COEFF_INTERP_OPT8X 1 793193640Sariff#elif Z_DRIFT_SHIFT == 2 794193640Sariff#define Z_COEFF_INTERP_OPT4X 1 795193640Sariff#elif Z_DRIFT_SHIFT == 1 796193640Sariff#define Z_COEFF_INTERP_OPT2X 1 797193640Sariff#else 798193640Sariff#error "Z_DRIFT_SHIFT screwed!" 799193640Sariff#endif 800193640Sariff#endif 801193640Sariff 802193640Sariff/* 803193640Sariff * In classic polyphase mode, the actual coefficients for each phases need to 804193640Sariff * be calculated based on default prototype filters. For highly oversampled 805193640Sariff * filter, linear or quadradatic interpolator should be enough. Anything less 806193640Sariff * than that require 'special' interpolators to reduce interpolation errors. 807193640Sariff * 808193640Sariff * "Polynomial Interpolators for High-Quality Resampling of Oversampled Audio" 809193640Sariff * by Olli Niemitalo 810193640Sariff * - http://www.student.oulu.fi/~oniemita/dsp/deip.pdf 811193640Sariff * 812193640Sariff */ 813193640Sariffstatic int32_t 814193640Sariffz_coeff_interpolate(int32_t z, int32_t *z_coeff) 815193640Sariff{ 816193640Sariff int32_t coeff; 817193640Sariff#if defined(Z_COEFF_INTERP_ZOH) 818193640Sariff 819193640Sariff /* 1-point, 0th-order (Zero Order Hold) */ 820193640Sariff z = z; 821193640Sariff coeff = z_coeff[0]; 822193640Sariff#elif defined(Z_COEFF_INTERP_LINEAR) 823193640Sariff int32_t zl0, zl1; 824193640Sariff 825193640Sariff /* 2-point, 1st-order Linear */ 826193640Sariff zl0 = z_coeff[0]; 827193640Sariff zl1 = z_coeff[1] - z_coeff[0]; 828193640Sariff 829195689Sariff coeff = Z_RSHIFT((int64_t)zl1 * z, Z_SHIFT) + zl0; 830193640Sariff#elif defined(Z_COEFF_INTERP_QUADRATIC) 831193640Sariff int32_t zq0, zq1, zq2; 832193640Sariff 833193640Sariff /* 3-point, 2nd-order Quadratic */ 834193640Sariff zq0 = z_coeff[0]; 835193640Sariff zq1 = z_coeff[1] - z_coeff[-1]; 836193640Sariff zq2 = z_coeff[1] + z_coeff[-1] - (z_coeff[0] << 1); 837193640Sariff 838195689Sariff coeff = Z_RSHIFT((Z_RSHIFT((int64_t)zq2 * z, Z_SHIFT) + 839195689Sariff zq1) * z, Z_SHIFT + 1) + zq0; 840193640Sariff#elif defined(Z_COEFF_INTERP_HERMITE) 841193640Sariff int32_t zh0, zh1, zh2, zh3; 842193640Sariff 843193640Sariff /* 4-point, 3rd-order Hermite */ 844193640Sariff zh0 = z_coeff[0]; 845193640Sariff zh1 = z_coeff[1] - z_coeff[-1]; 846193640Sariff zh2 = (z_coeff[-1] << 1) - (z_coeff[0] * 5) + (z_coeff[1] << 2) - 847193640Sariff z_coeff[2]; 848193640Sariff zh3 = z_coeff[2] - z_coeff[-1] + ((z_coeff[0] - z_coeff[1]) * 3); 849193640Sariff 850195689Sariff coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((int64_t)zh3 * z, Z_SHIFT) + 851195689Sariff zh2) * z, Z_SHIFT) + zh1) * z, Z_SHIFT + 1) + zh0; 852193640Sariff#elif defined(Z_COEFF_INTERP_BSPLINE) 853193640Sariff int32_t zb0, zb1, zb2, zb3; 854193640Sariff 855193640Sariff /* 4-point, 3rd-order B-Spline */ 856195689Sariff zb0 = Z_RSHIFT(0x15555555LL * (((int64_t)z_coeff[0] << 2) + 857195689Sariff z_coeff[-1] + z_coeff[1]), 30); 858193640Sariff zb1 = z_coeff[1] - z_coeff[-1]; 859193640Sariff zb2 = z_coeff[-1] + z_coeff[1] - (z_coeff[0] << 1); 860195689Sariff zb3 = Z_RSHIFT(0x15555555LL * (((z_coeff[0] - z_coeff[1]) * 3) + 861195689Sariff z_coeff[2] - z_coeff[-1]), 30); 862193640Sariff 863195689Sariff coeff = (Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((int64_t)zb3 * z, Z_SHIFT) + 864195689Sariff zb2) * z, Z_SHIFT) + zb1) * z, Z_SHIFT) + zb0 + 1) >> 1; 865193640Sariff#elif defined(Z_COEFF_INTERP_OPT32X) 866193640Sariff int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3; 867193640Sariff int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5; 868193640Sariff 869193640Sariff /* 6-point, 5th-order Optimal 32x */ 870193640Sariff zoz = z - (Z_ONE >> 1); 871193640Sariff zoe1 = z_coeff[1] + z_coeff[0]; 872193640Sariff zoe2 = z_coeff[2] + z_coeff[-1]; 873193640Sariff zoe3 = z_coeff[3] + z_coeff[-2]; 874193640Sariff zoo1 = z_coeff[1] - z_coeff[0]; 875193640Sariff zoo2 = z_coeff[2] - z_coeff[-1]; 876193640Sariff zoo3 = z_coeff[3] - z_coeff[-2]; 877193640Sariff 878195689Sariff zoc0 = Z_RSHIFT((0x1ac2260dLL * zoe1) + (0x0526cdcaLL * zoe2) + 879195689Sariff (0x00170c29LL * zoe3), 30); 880195689Sariff zoc1 = Z_RSHIFT((0x14f8a49aLL * zoo1) + (0x0d6d1109LL * zoo2) + 881195689Sariff (0x008cd4dcLL * zoo3), 30); 882195689Sariff zoc2 = Z_RSHIFT((-0x0d3e94a4LL * zoe1) + (0x0bddded4LL * zoe2) + 883195689Sariff (0x0160b5d0LL * zoe3), 30); 884195689Sariff zoc3 = Z_RSHIFT((-0x0de10cc4LL * zoo1) + (0x019b2a7dLL * zoo2) + 885195689Sariff (0x01cfe914LL * zoo3), 30); 886195689Sariff zoc4 = Z_RSHIFT((0x02aa12d7LL * zoe1) + (-0x03ff1bb3LL * zoe2) + 887195689Sariff (0x015508ddLL * zoe3), 30); 888195689Sariff zoc5 = Z_RSHIFT((0x051d29e5LL * zoo1) + (-0x028e7647LL * zoo2) + 889195689Sariff (0x0082d81aLL * zoo3), 30); 890193640Sariff 891195689Sariff coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT( 892195689Sariff (int64_t)zoc5 * zoz, Z_SHIFT) + 893195689Sariff zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) + 894195689Sariff zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0; 895193640Sariff#elif defined(Z_COEFF_INTERP_OPT16X) 896193640Sariff int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3; 897193640Sariff int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5; 898193640Sariff 899193640Sariff /* 6-point, 5th-order Optimal 16x */ 900193640Sariff zoz = z - (Z_ONE >> 1); 901193640Sariff zoe1 = z_coeff[1] + z_coeff[0]; 902193640Sariff zoe2 = z_coeff[2] + z_coeff[-1]; 903193640Sariff zoe3 = z_coeff[3] + z_coeff[-2]; 904193640Sariff zoo1 = z_coeff[1] - z_coeff[0]; 905193640Sariff zoo2 = z_coeff[2] - z_coeff[-1]; 906193640Sariff zoo3 = z_coeff[3] - z_coeff[-2]; 907193640Sariff 908195689Sariff zoc0 = Z_RSHIFT((0x1ac2260dLL * zoe1) + (0x0526cdcaLL * zoe2) + 909195689Sariff (0x00170c29LL * zoe3), 30); 910195689Sariff zoc1 = Z_RSHIFT((0x14f8a49aLL * zoo1) + (0x0d6d1109LL * zoo2) + 911195689Sariff (0x008cd4dcLL * zoo3), 30); 912195689Sariff zoc2 = Z_RSHIFT((-0x0d3e94a4LL * zoe1) + (0x0bddded4LL * zoe2) + 913195689Sariff (0x0160b5d0LL * zoe3), 30); 914195689Sariff zoc3 = Z_RSHIFT((-0x0de10cc4LL * zoo1) + (0x019b2a7dLL * zoo2) + 915195689Sariff (0x01cfe914LL * zoo3), 30); 916195689Sariff zoc4 = Z_RSHIFT((0x02aa12d7LL * zoe1) + (-0x03ff1bb3LL * zoe2) + 917195689Sariff (0x015508ddLL * zoe3), 30); 918195689Sariff zoc5 = Z_RSHIFT((0x051d29e5LL * zoo1) + (-0x028e7647LL * zoo2) + 919195689Sariff (0x0082d81aLL * zoo3), 30); 920193640Sariff 921195689Sariff coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT( 922195689Sariff (int64_t)zoc5 * zoz, Z_SHIFT) + 923195689Sariff zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) + 924195689Sariff zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0; 925193640Sariff#elif defined(Z_COEFF_INTERP_OPT8X) 926193640Sariff int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3; 927193640Sariff int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5; 928193640Sariff 929193640Sariff /* 6-point, 5th-order Optimal 8x */ 930193640Sariff zoz = z - (Z_ONE >> 1); 931193640Sariff zoe1 = z_coeff[1] + z_coeff[0]; 932193640Sariff zoe2 = z_coeff[2] + z_coeff[-1]; 933193640Sariff zoe3 = z_coeff[3] + z_coeff[-2]; 934193640Sariff zoo1 = z_coeff[1] - z_coeff[0]; 935193640Sariff zoo2 = z_coeff[2] - z_coeff[-1]; 936193640Sariff zoo3 = z_coeff[3] - z_coeff[-2]; 937193640Sariff 938195689Sariff zoc0 = Z_RSHIFT((0x1aa9b47dLL * zoe1) + (0x053d9944LL * zoe2) + 939195689Sariff (0x0018b23fLL * zoe3), 30); 940195689Sariff zoc1 = Z_RSHIFT((0x14a104d1LL * zoo1) + (0x0d7d2504LL * zoo2) + 941195689Sariff (0x0094b599LL * zoo3), 30); 942195689Sariff zoc2 = Z_RSHIFT((-0x0d22530bLL * zoe1) + (0x0bb37a2cLL * zoe2) + 943195689Sariff (0x016ed8e0LL * zoe3), 30); 944195689Sariff zoc3 = Z_RSHIFT((-0x0d744b1cLL * zoo1) + (0x01649591LL * zoo2) + 945195689Sariff (0x01dae93aLL * zoo3), 30); 946195689Sariff zoc4 = Z_RSHIFT((0x02a7ee1bLL * zoe1) + (-0x03fbdb24LL * zoe2) + 947195689Sariff (0x0153ed07LL * zoe3), 30); 948195689Sariff zoc5 = Z_RSHIFT((0x04cf9b6cLL * zoo1) + (-0x0266b378LL * zoo2) + 949195689Sariff (0x007a7c26LL * zoo3), 30); 950193640Sariff 951195689Sariff coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT( 952195689Sariff (int64_t)zoc5 * zoz, Z_SHIFT) + 953195689Sariff zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) + 954195689Sariff zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0; 955193640Sariff#elif defined(Z_COEFF_INTERP_OPT4X) 956193640Sariff int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3; 957193640Sariff int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5; 958193640Sariff 959193640Sariff /* 6-point, 5th-order Optimal 4x */ 960193640Sariff zoz = z - (Z_ONE >> 1); 961193640Sariff zoe1 = z_coeff[1] + z_coeff[0]; 962193640Sariff zoe2 = z_coeff[2] + z_coeff[-1]; 963193640Sariff zoe3 = z_coeff[3] + z_coeff[-2]; 964193640Sariff zoo1 = z_coeff[1] - z_coeff[0]; 965193640Sariff zoo2 = z_coeff[2] - z_coeff[-1]; 966193640Sariff zoo3 = z_coeff[3] - z_coeff[-2]; 967193640Sariff 968195689Sariff zoc0 = Z_RSHIFT((0x1a8eda43LL * zoe1) + (0x0556ee38LL * zoe2) + 969195689Sariff (0x001a3784LL * zoe3), 30); 970195689Sariff zoc1 = Z_RSHIFT((0x143d863eLL * zoo1) + (0x0d910e36LL * zoo2) + 971195689Sariff (0x009ca889LL * zoo3), 30); 972195689Sariff zoc2 = Z_RSHIFT((-0x0d026821LL * zoe1) + (0x0b837773LL * zoe2) + 973195689Sariff (0x017ef0c6LL * zoe3), 30); 974195689Sariff zoc3 = Z_RSHIFT((-0x0cef1502LL * zoo1) + (0x01207a8eLL * zoo2) + 975195689Sariff (0x01e936dbLL * zoo3), 30); 976195689Sariff zoc4 = Z_RSHIFT((0x029fe643LL * zoe1) + (-0x03ef3fc8LL * zoe2) + 977195689Sariff (0x014f5923LL * zoe3), 30); 978195689Sariff zoc5 = Z_RSHIFT((0x043a9d08LL * zoo1) + (-0x02154febLL * zoo2) + 979195689Sariff (0x00670dbdLL * zoo3), 30); 980193640Sariff 981195689Sariff coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT( 982195689Sariff (int64_t)zoc5 * zoz, Z_SHIFT) + 983195689Sariff zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) + 984195689Sariff zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0; 985193640Sariff#elif defined(Z_COEFF_INTERP_OPT2X) 986193640Sariff int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3; 987193640Sariff int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5; 988193640Sariff 989193640Sariff /* 6-point, 5th-order Optimal 2x */ 990193640Sariff zoz = z - (Z_ONE >> 1); 991193640Sariff zoe1 = z_coeff[1] + z_coeff[0]; 992193640Sariff zoe2 = z_coeff[2] + z_coeff[-1]; 993193640Sariff zoe3 = z_coeff[3] + z_coeff[-2]; 994193640Sariff zoo1 = z_coeff[1] - z_coeff[0]; 995193640Sariff zoo2 = z_coeff[2] - z_coeff[-1]; 996193640Sariff zoo3 = z_coeff[3] - z_coeff[-2]; 997193640Sariff 998195689Sariff zoc0 = Z_RSHIFT((0x19edb6fdLL * zoe1) + (0x05ebd062LL * zoe2) + 999195689Sariff (0x00267881LL * zoe3), 30); 1000195689Sariff zoc1 = Z_RSHIFT((0x1223af76LL * zoo1) + (0x0de3dd6bLL * zoo2) + 1001195689Sariff (0x00d683cdLL * zoo3), 30); 1002195689Sariff zoc2 = Z_RSHIFT((-0x0c3ee068LL * zoe1) + (0x0a5c3769LL * zoe2) + 1003195689Sariff (0x01e2aceaLL * zoe3), 30); 1004195689Sariff zoc3 = Z_RSHIFT((-0x0a8ab614LL * zoo1) + (-0x0019522eLL * zoo2) + 1005195689Sariff (0x022cefc7LL * zoo3), 30); 1006195689Sariff zoc4 = Z_RSHIFT((0x0276187dLL * zoe1) + (-0x03a801e8LL * zoe2) + 1007195689Sariff (0x0131d935LL * zoe3), 30); 1008195689Sariff zoc5 = Z_RSHIFT((0x02c373f5LL * zoo1) + (-0x01275f83LL * zoo2) + 1009195689Sariff (0x0018ee79LL * zoo3), 30); 1010193640Sariff 1011195689Sariff coeff = Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT((Z_RSHIFT( 1012195689Sariff (int64_t)zoc5 * zoz, Z_SHIFT) + 1013195689Sariff zoc4) * zoz, Z_SHIFT) + zoc3) * zoz, Z_SHIFT) + 1014195689Sariff zoc2) * zoz, Z_SHIFT) + zoc1) * zoz, Z_SHIFT) + zoc0; 1015193640Sariff#else 1016193640Sariff#error "Interpolation type screwed!" 1017193640Sariff#endif 1018193640Sariff 1019193640Sariff#if Z_POLYPHASE_COEFF_SHIFT > 0 1020193640Sariff coeff = Z_RSHIFT(coeff, Z_POLYPHASE_COEFF_SHIFT); 1021193640Sariff#endif 1022193640Sariff return (coeff); 1023193640Sariff} 1024193640Sariff 1025193640Sariffstatic int 1026193640Sariffz_resampler_build_polyphase(struct z_info *info) 1027193640Sariff{ 1028193640Sariff int32_t alpha, c, i, z, idx; 1029193640Sariff 1030193640Sariff /* Let this be here first. */ 1031193640Sariff if (info->z_pcoeff != NULL) { 1032193640Sariff free(info->z_pcoeff, M_DEVBUF); 1033193640Sariff info->z_pcoeff = NULL; 1034193640Sariff } 1035193640Sariff 1036193640Sariff if (feeder_rate_polyphase_max < 1) 1037193640Sariff return (ENOTSUP); 1038193640Sariff 1039193640Sariff if (((int64_t)info->z_size * info->z_gy * 2) > 1040193640Sariff feeder_rate_polyphase_max) { 1041193640Sariff#ifndef _KERNEL 1042193640Sariff fprintf(stderr, "Polyphase entries exceed: [%d/%d] %jd > %d\n", 1043193640Sariff info->z_gx, info->z_gy, 1044193640Sariff (intmax_t)info->z_size * info->z_gy * 2, 1045193640Sariff feeder_rate_polyphase_max); 1046193640Sariff#endif 1047193640Sariff return (E2BIG); 1048193640Sariff } 1049193640Sariff 1050193640Sariff info->z_pcoeff = malloc(sizeof(int32_t) * 1051193640Sariff info->z_size * info->z_gy * 2, M_DEVBUF, M_NOWAIT | M_ZERO); 1052193640Sariff if (info->z_pcoeff == NULL) 1053193640Sariff return (ENOMEM); 1054193640Sariff 1055193640Sariff for (alpha = 0; alpha < info->z_gy; alpha++) { 1056193640Sariff z = alpha * info->z_dx; 1057193640Sariff c = 0; 1058193640Sariff for (i = info->z_size; i != 0; i--) { 1059193640Sariff c += z >> Z_SHIFT; 1060193640Sariff z &= Z_MASK; 1061193640Sariff idx = (alpha * info->z_size * 2) + 1062193640Sariff (info->z_size * 2) - i; 1063193640Sariff info->z_pcoeff[idx] = 1064193640Sariff z_coeff_interpolate(z, info->z_coeff + c); 1065193640Sariff z += info->z_dy; 1066193640Sariff } 1067193640Sariff z = info->z_dy - (alpha * info->z_dx); 1068193640Sariff c = 0; 1069193640Sariff for (i = info->z_size; i != 0; i--) { 1070193640Sariff c += z >> Z_SHIFT; 1071193640Sariff z &= Z_MASK; 1072193640Sariff idx = (alpha * info->z_size * 2) + i - 1; 1073193640Sariff info->z_pcoeff[idx] = 1074193640Sariff z_coeff_interpolate(z, info->z_coeff + c); 1075193640Sariff z += info->z_dy; 1076193640Sariff } 1077193640Sariff } 1078193640Sariff 1079193640Sariff#ifndef _KERNEL 1080193640Sariff fprintf(stderr, "Polyphase: [%d/%d] %d entries\n", 1081193640Sariff info->z_gx, info->z_gy, info->z_size * info->z_gy * 2); 1082193640Sariff#endif 1083193640Sariff 1084193640Sariff return (0); 1085193640Sariff} 1086193640Sariff 1087193640Sariffstatic int 1088193640Sariffz_resampler_setup(struct pcm_feeder *f) 1089193640Sariff{ 1090193640Sariff struct z_info *info; 1091193640Sariff int64_t gy2gx_max, gx2gy_max; 1092193640Sariff uint32_t format; 1093193640Sariff int32_t align, i, z_scale; 1094193640Sariff int adaptive; 1095193640Sariff 1096193640Sariff info = f->data; 1097193640Sariff z_resampler_reset(info); 1098193640Sariff 1099193640Sariff if (info->src == info->dst) 1100193640Sariff return (0); 1101193640Sariff 1102193640Sariff /* Shrink by greatest common divisor. */ 1103193640Sariff i = z_gcd(info->src, info->dst); 1104193640Sariff info->z_gx = info->src / i; 1105193640Sariff info->z_gy = info->dst / i; 1106193640Sariff 1107193640Sariff /* Too big, or too small. Bail out. */ 1108193640Sariff if (!(Z_FACTOR_SAFE(info->z_gx) && Z_FACTOR_SAFE(info->z_gy))) 1109193640Sariff return (EINVAL); 1110193640Sariff 1111193640Sariff format = f->desc->in; 1112193640Sariff adaptive = 0; 1113193640Sariff z_scale = 0; 1114193640Sariff 1115193640Sariff /* 1116193640Sariff * Setup everything: filter length, conversion factor, etc. 1117193640Sariff */ 1118193640Sariff if (Z_IS_SINC(info)) { 1119193640Sariff /* 1120193640Sariff * Downsampling, or upsampling scaling factor. As long as the 1121193640Sariff * factor can be represented by a fraction of 1 << Z_SHIFT, 1122193640Sariff * we're pretty much in business. Scaling is not needed for 1123193640Sariff * upsampling, so we just slap Z_ONE there. 1124193640Sariff */ 1125193640Sariff if (info->z_gx > info->z_gy) 1126193640Sariff /* 1127193640Sariff * If the downsampling ratio is beyond sanity, 1128193640Sariff * enable semi-adaptive mode. Although handling 1129193640Sariff * extreme ratio is possible, the result of the 1130193640Sariff * conversion is just pointless, unworthy, 1131193640Sariff * nonsensical noises, etc. 1132193640Sariff */ 1133193640Sariff if ((info->z_gx / info->z_gy) > Z_SINC_DOWNMAX) 1134193640Sariff z_scale = Z_ONE / Z_SINC_DOWNMAX; 1135193640Sariff else 1136193640Sariff z_scale = ((uint64_t)info->z_gy << Z_SHIFT) / 1137193640Sariff info->z_gx; 1138193640Sariff else 1139193640Sariff z_scale = Z_ONE; 1140193640Sariff 1141193640Sariff /* 1142193640Sariff * This is actually impossible, unless anything above 1143193640Sariff * overflow. 1144193640Sariff */ 1145193640Sariff if (z_scale < 1) 1146193640Sariff return (E2BIG); 1147193640Sariff 1148193640Sariff /* 1149193640Sariff * Calculate sample time/coefficients index drift. It is 1150193640Sariff * a constant for upsampling, but downsampling require 1151193640Sariff * heavy duty filtering with possible too long filters. 1152193640Sariff * If anything goes wrong, revisit again and enable 1153193640Sariff * adaptive mode. 1154193640Sariff */ 1155193640Sariffz_setup_adaptive_sinc: 1156193640Sariff if (info->z_pcoeff != NULL) { 1157193640Sariff free(info->z_pcoeff, M_DEVBUF); 1158193640Sariff info->z_pcoeff = NULL; 1159193640Sariff } 1160193640Sariff 1161193640Sariff if (adaptive == 0) { 1162193640Sariff info->z_dy = z_scale << Z_DRIFT_SHIFT; 1163193640Sariff if (info->z_dy < 1) 1164193640Sariff return (E2BIG); 1165193640Sariff info->z_scale = z_scale; 1166193640Sariff } else { 1167193640Sariff info->z_dy = Z_FULL_ONE; 1168193640Sariff info->z_scale = Z_ONE; 1169193640Sariff } 1170193640Sariff 1171193640Sariff#if 0 1172193640Sariff#define Z_SCALE_DIV 10000 1173193640Sariff#define Z_SCALE_LIMIT(s, v) \ 1174193640Sariff ((((uint64_t)(s) * (v)) + (Z_SCALE_DIV >> 1)) / Z_SCALE_DIV) 1175193640Sariff 1176193640Sariff info->z_scale = Z_SCALE_LIMIT(info->z_scale, 9780); 1177193640Sariff#endif 1178193640Sariff 1179193640Sariff /* Smallest drift increment. */ 1180193640Sariff info->z_dx = info->z_dy / info->z_gy; 1181193640Sariff 1182193640Sariff /* 1183193640Sariff * Overflow or underflow. Try adaptive, let it continue and 1184193640Sariff * retry. 1185193640Sariff */ 1186193640Sariff if (info->z_dx < 1) { 1187193640Sariff if (adaptive == 0) { 1188193640Sariff adaptive = 1; 1189193640Sariff goto z_setup_adaptive_sinc; 1190193640Sariff } 1191193640Sariff return (E2BIG); 1192193640Sariff } 1193193640Sariff 1194193640Sariff /* 1195193640Sariff * Round back output drift. 1196193640Sariff */ 1197193640Sariff info->z_dy = info->z_dx * info->z_gy; 1198193640Sariff 1199193640Sariff for (i = 0; i < Z_COEFF_TAB_SIZE; i++) { 1200193640Sariff if (Z_SINC_COEFF_IDX(info) != i) 1201193640Sariff continue; 1202193640Sariff /* 1203193640Sariff * Calculate required filter length and guard 1204193640Sariff * against possible abusive result. Note that 1205193640Sariff * this represents only 1/2 of the entire filter 1206193640Sariff * length. 1207193640Sariff */ 1208193640Sariff info->z_size = z_resampler_sinc_len(info); 1209193640Sariff 1210193640Sariff /* 1211193640Sariff * Multiple of 2 rounding, for better accumulator 1212193640Sariff * performance. 1213193640Sariff */ 1214193640Sariff info->z_size &= ~1; 1215193640Sariff 1216193640Sariff if (info->z_size < 2 || info->z_size > Z_SINC_MAX) { 1217193640Sariff if (adaptive == 0) { 1218193640Sariff adaptive = 1; 1219193640Sariff goto z_setup_adaptive_sinc; 1220193640Sariff } 1221193640Sariff return (E2BIG); 1222193640Sariff } 1223193640Sariff info->z_coeff = z_coeff_tab[i].coeff + Z_COEFF_OFFSET; 1224193640Sariff info->z_dcoeff = z_coeff_tab[i].dcoeff; 1225164614Sariff break; 1226148606Snetchild } 1227193640Sariff 1228193640Sariff if (info->z_coeff == NULL || info->z_dcoeff == NULL) 1229193640Sariff return (EINVAL); 1230193640Sariff } else if (Z_IS_LINEAR(info)) { 1231193640Sariff /* 1232193640Sariff * Don't put much effort if we're doing linear interpolation. 1233193640Sariff * Just center the interpolation distance within Z_LINEAR_ONE, 1234193640Sariff * and be happy about it. 1235193640Sariff */ 1236193640Sariff info->z_dx = Z_LINEAR_FULL_ONE / info->z_gy; 1237109547Sorion } 1238164614Sariff 1239164614Sariff /* 1240193640Sariff * We're safe for now, lets continue.. Look for our resampler 1241193640Sariff * depending on configured format and quality. 1242164614Sariff */ 1243193640Sariff for (i = 0; i < Z_RESAMPLER_TAB_SIZE; i++) { 1244193640Sariff int ridx; 1245164614Sariff 1246193640Sariff if (AFMT_ENCODING(format) != z_resampler_tab[i].format) 1247193640Sariff continue; 1248193640Sariff if (Z_IS_SINC(info) && adaptive == 0 && 1249193640Sariff z_resampler_build_polyphase(info) == 0) 1250193640Sariff ridx = Z_RESAMPLER_SINC_POLYPHASE; 1251193640Sariff else 1252193640Sariff ridx = Z_RESAMPLER_IDX(info); 1253193640Sariff info->z_resample = z_resampler_tab[i].resampler[ridx]; 1254193640Sariff break; 1255193640Sariff } 1256164614Sariff 1257193640Sariff if (info->z_resample == NULL) 1258193640Sariff return (EINVAL); 1259164614Sariff 1260193640Sariff info->bps = AFMT_BPS(format); 1261193640Sariff align = info->channels * info->bps; 1262164614Sariff 1263193640Sariff /* 1264193640Sariff * Calculate largest value that can be fed into z_gy2gx() and 1265193640Sariff * z_gx2gy() without causing (signed) 32bit overflow. z_gy2gx() will 1266193640Sariff * be called early during feeding process to determine how much input 1267193640Sariff * samples that is required to generate requested output, while 1268193640Sariff * z_gx2gy() will be called just before samples filtering / 1269193640Sariff * accumulation process based on available samples that has been 1270193640Sariff * calculated using z_gx2gy(). 1271193640Sariff * 1272193640Sariff * Now that is damn confusing, I guess ;-) . 1273193640Sariff */ 1274193640Sariff gy2gx_max = (((uint64_t)info->z_gy * INT32_MAX) - info->z_gy + 1) / 1275193640Sariff info->z_gx; 1276193640Sariff 1277193640Sariff if ((gy2gx_max * align) > SND_FXDIV_MAX) 1278193640Sariff gy2gx_max = SND_FXDIV_MAX / align; 1279193640Sariff 1280193640Sariff if (gy2gx_max < 1) 1281193640Sariff return (E2BIG); 1282193640Sariff 1283193640Sariff gx2gy_max = (((uint64_t)info->z_gx * INT32_MAX) - info->z_gy) / 1284193640Sariff info->z_gy; 1285193640Sariff 1286193640Sariff if (gx2gy_max > INT32_MAX) 1287193640Sariff gx2gy_max = INT32_MAX; 1288193640Sariff 1289193640Sariff if (gx2gy_max < 1) 1290193640Sariff return (E2BIG); 1291193640Sariff 1292193640Sariff /* 1293193640Sariff * Ensure that z_gy2gx() at its largest possible calculated value 1294193640Sariff * (alpha = 0) will not cause overflow further late during z_gx2gy() 1295193640Sariff * stage. 1296193640Sariff */ 1297193640Sariff if (z_gy2gx(info, gy2gx_max) > _Z_GCAST(gx2gy_max)) 1298193640Sariff return (E2BIG); 1299193640Sariff 1300193640Sariff info->z_maxfeed = gy2gx_max * align; 1301193640Sariff 1302193640Sariff#ifdef Z_USE_ALPHADRIFT 1303193640Sariff info->z_startdrift = z_gy2gx(info, 1); 1304193640Sariff info->z_alphadrift = z_drift(info, info->z_startdrift, 1); 1305193640Sariff#endif 1306193640Sariff 1307193640Sariff i = z_gy2gx(info, 1); 1308193640Sariff info->z_full = z_roundpow2((info->z_size << 1) + i); 1309193640Sariff 1310193640Sariff /* 1311193640Sariff * Too big to be true, and overflowing left and right like mad .. 1312193640Sariff */ 1313193640Sariff if ((info->z_full * align) < 1) { 1314193640Sariff if (adaptive == 0 && Z_IS_SINC(info)) { 1315193640Sariff adaptive = 1; 1316193640Sariff goto z_setup_adaptive_sinc; 1317193640Sariff } 1318193640Sariff return (E2BIG); 1319193640Sariff } 1320193640Sariff 1321193640Sariff /* 1322193640Sariff * Increase full buffer size if its too small to reduce cyclic 1323193640Sariff * buffer shifting in main conversion/feeder loop. 1324193640Sariff */ 1325193640Sariff while (info->z_full < Z_RESERVOIR_MAX && 1326193640Sariff (info->z_full - (info->z_size << 1)) < Z_RESERVOIR) 1327193640Sariff info->z_full <<= 1; 1328193640Sariff 1329193640Sariff /* Initialize buffer position. */ 1330193640Sariff info->z_mask = info->z_full - 1; 1331193640Sariff info->z_start = z_prev(info, info->z_size << 1, 1); 1332193640Sariff info->z_pos = z_next(info, info->z_start, 1); 1333193640Sariff 1334193640Sariff /* 1335193640Sariff * Allocate or reuse delay line buffer, whichever makes sense. 1336193640Sariff */ 1337193640Sariff i = info->z_full * align; 1338193640Sariff if (i < 1) 1339193640Sariff return (E2BIG); 1340193640Sariff 1341193640Sariff if (info->z_delay == NULL || info->z_alloc < i || 1342193640Sariff i <= (info->z_alloc >> 1)) { 1343193640Sariff if (info->z_delay != NULL) 1344193640Sariff free(info->z_delay, M_DEVBUF); 1345193640Sariff info->z_delay = malloc(i, M_DEVBUF, M_NOWAIT | M_ZERO); 1346193640Sariff if (info->z_delay == NULL) 1347193640Sariff return (ENOMEM); 1348193640Sariff info->z_alloc = i; 1349193640Sariff } 1350193640Sariff 1351193640Sariff /* 1352193640Sariff * Zero out head of buffer to avoid pops and clicks. 1353193640Sariff */ 1354193640Sariff memset(info->z_delay, sndbuf_zerodata(f->desc->out), 1355193640Sariff info->z_pos * align); 1356193640Sariff 1357193640Sariff#ifdef Z_DIAGNOSTIC 1358193640Sariff /* 1359193640Sariff * XXX Debuging mess !@#$%^ 1360193640Sariff */ 1361193640Sariff#define dumpz(x) fprintf(stderr, "\t%12s = %10u : %-11d\n", \ 1362193640Sariff "z_"__STRING(x), (uint32_t)info->z_##x, \ 1363193640Sariff (int32_t)info->z_##x) 1364193640Sariff fprintf(stderr, "\n%s():\n", __func__); 1365193640Sariff fprintf(stderr, "\tchannels=%d, bps=%d, format=0x%08x, quality=%d\n", 1366193640Sariff info->channels, info->bps, format, info->quality); 1367193640Sariff fprintf(stderr, "\t%d (%d) -> %d (%d), ", 1368193640Sariff info->src, info->rsrc, info->dst, info->rdst); 1369193640Sariff fprintf(stderr, "[%d/%d]\n", info->z_gx, info->z_gy); 1370193640Sariff fprintf(stderr, "\tminreq=%d, ", z_gy2gx(info, 1)); 1371193640Sariff if (adaptive != 0) 1372193640Sariff z_scale = Z_ONE; 1373193640Sariff fprintf(stderr, "factor=0x%08x/0x%08x (%f)\n", 1374193640Sariff z_scale, Z_ONE, (double)z_scale / Z_ONE); 1375193640Sariff fprintf(stderr, "\tbase_length=%d, ", Z_SINC_BASE_LEN(info)); 1376193640Sariff fprintf(stderr, "adaptive=%s\n", (adaptive != 0) ? "YES" : "NO"); 1377193640Sariff dumpz(size); 1378193640Sariff dumpz(alloc); 1379193640Sariff if (info->z_alloc < 1024) 1380193640Sariff fprintf(stderr, "\t%15s%10d Bytes\n", 1381193640Sariff "", info->z_alloc); 1382193640Sariff else if (info->z_alloc < (1024 << 10)) 1383193640Sariff fprintf(stderr, "\t%15s%10d KBytes\n", 1384193640Sariff "", info->z_alloc >> 10); 1385193640Sariff else if (info->z_alloc < (1024 << 20)) 1386193640Sariff fprintf(stderr, "\t%15s%10d MBytes\n", 1387193640Sariff "", info->z_alloc >> 20); 1388193640Sariff else 1389193640Sariff fprintf(stderr, "\t%15s%10d GBytes\n", 1390193640Sariff "", info->z_alloc >> 30); 1391193640Sariff fprintf(stderr, "\t%12s %10d (min output samples)\n", 1392193640Sariff "", 1393193640Sariff (int32_t)z_gx2gy(info, info->z_full - (info->z_size << 1))); 1394193640Sariff fprintf(stderr, "\t%12s %10d (min allocated output samples)\n", 1395193640Sariff "", 1396193640Sariff (int32_t)z_gx2gy(info, (info->z_alloc / align) - 1397193640Sariff (info->z_size << 1))); 1398193640Sariff fprintf(stderr, "\t%12s = %10d\n", 1399193640Sariff "z_gy2gx()", (int32_t)z_gy2gx(info, 1)); 1400193640Sariff fprintf(stderr, "\t%12s = %10d -> z_gy2gx() -> %d\n", 1401193640Sariff "Max", (int32_t)gy2gx_max, (int32_t)z_gy2gx(info, gy2gx_max)); 1402193640Sariff fprintf(stderr, "\t%12s = %10d\n", 1403193640Sariff "z_gx2gy()", (int32_t)z_gx2gy(info, 1)); 1404193640Sariff fprintf(stderr, "\t%12s = %10d -> z_gx2gy() -> %d\n", 1405193640Sariff "Max", (int32_t)gx2gy_max, (int32_t)z_gx2gy(info, gx2gy_max)); 1406193640Sariff dumpz(maxfeed); 1407193640Sariff dumpz(full); 1408193640Sariff dumpz(start); 1409193640Sariff dumpz(pos); 1410193640Sariff dumpz(scale); 1411193640Sariff fprintf(stderr, "\t%12s %10f\n", "", 1412193640Sariff (double)info->z_scale / Z_ONE); 1413193640Sariff dumpz(dx); 1414193640Sariff fprintf(stderr, "\t%12s %10f\n", "", 1415193640Sariff (double)info->z_dx / info->z_dy); 1416193640Sariff dumpz(dy); 1417193640Sariff fprintf(stderr, "\t%12s %10d (drift step)\n", "", 1418193640Sariff info->z_dy >> Z_SHIFT); 1419193640Sariff fprintf(stderr, "\t%12s %10d (scaling differences)\n", "", 1420193640Sariff (z_scale << Z_DRIFT_SHIFT) - info->z_dy); 1421193640Sariff fprintf(stderr, "\t%12s = %u bytes\n", 1422193640Sariff "intpcm32_t", sizeof(intpcm32_t)); 1423193640Sariff fprintf(stderr, "\t%12s = 0x%08x, smallest=%.16lf\n", 1424193640Sariff "Z_ONE", Z_ONE, (double)1.0 / (double)Z_ONE); 1425193640Sariff#endif 1426193640Sariff 1427167646Sariff return (0); 142875320Scg} 142975320Scg 143075320Scgstatic int 1431193640Sariffz_resampler_set(struct pcm_feeder *f, int what, int32_t value) 143275320Scg{ 1433193640Sariff struct z_info *info; 1434193640Sariff int32_t oquality; 1435148606Snetchild 1436193640Sariff info = f->data; 1437164614Sariff 1438148606Snetchild switch (what) { 1439193640Sariff case Z_RATE_SRC: 1440193640Sariff if (value < feeder_rate_min || value > feeder_rate_max) 1441193640Sariff return (E2BIG); 1442193640Sariff if (value == info->rsrc) 1443193640Sariff return (0); 1444164614Sariff info->rsrc = value; 1445164614Sariff break; 1446193640Sariff case Z_RATE_DST: 1447193640Sariff if (value < feeder_rate_min || value > feeder_rate_max) 1448193640Sariff return (E2BIG); 1449193640Sariff if (value == info->rdst) 1450193640Sariff return (0); 1451164614Sariff info->rdst = value; 1452164614Sariff break; 1453193640Sariff case Z_RATE_QUALITY: 1454193640Sariff if (value < Z_QUALITY_MIN || value > Z_QUALITY_MAX) 1455193640Sariff return (EINVAL); 1456193640Sariff if (value == info->quality) 1457193640Sariff return (0); 1458193640Sariff /* 1459193640Sariff * If we failed to set the requested quality, restore 1460193640Sariff * the old one. We cannot afford leaving it broken since 1461193640Sariff * passive feeder chains like vchans never reinitialize 1462193640Sariff * itself. 1463193640Sariff */ 1464193640Sariff oquality = info->quality; 1465193640Sariff info->quality = value; 1466193640Sariff if (z_resampler_setup(f) == 0) 1467193640Sariff return (0); 1468193640Sariff info->quality = oquality; 1469193640Sariff break; 1470193640Sariff case Z_RATE_CHANNELS: 1471193640Sariff if (value < SND_CHN_MIN || value > SND_CHN_MAX) 1472193640Sariff return (EINVAL); 1473193640Sariff if (value == info->channels) 1474193640Sariff return (0); 1475193640Sariff info->channels = value; 1476193640Sariff break; 1477164614Sariff default: 1478193640Sariff return (EINVAL); 1479193640Sariff break; 1480110108Sorion } 1481193640Sariff 1482193640Sariff return (z_resampler_setup(f)); 148375320Scg} 148475320Scg 148575320Scgstatic int 1486193640Sariffz_resampler_get(struct pcm_feeder *f, int what) 148777266Scg{ 1488193640Sariff struct z_info *info; 148977266Scg 1490193640Sariff info = f->data; 1491193640Sariff 1492148606Snetchild switch (what) { 1493193640Sariff case Z_RATE_SRC: 1494167646Sariff return (info->rsrc); 1495193640Sariff break; 1496193640Sariff case Z_RATE_DST: 1497167646Sariff return (info->rdst); 1498193640Sariff break; 1499193640Sariff case Z_RATE_QUALITY: 1500193640Sariff return (info->quality); 1501193640Sariff break; 1502193640Sariff case Z_RATE_CHANNELS: 1503193640Sariff return (info->channels); 1504193640Sariff break; 1505164614Sariff default: 1506193640Sariff break; 150777266Scg } 1508193640Sariff 1509167646Sariff return (-1); 151077266Scg} 151177266Scg 151277266Scgstatic int 1513193640Sariffz_resampler_init(struct pcm_feeder *f) 151475320Scg{ 1515193640Sariff struct z_info *info; 1516193640Sariff int ret; 151775320Scg 1518193640Sariff if (f->desc->in != f->desc->out) 1519167646Sariff return (EINVAL); 1520164614Sariff 1521193640Sariff info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO); 1522113752Sorion if (info == NULL) 1523167646Sariff return (ENOMEM); 1524193640Sariff 1525193640Sariff info->rsrc = Z_RATE_DEFAULT; 1526193640Sariff info->rdst = Z_RATE_DEFAULT; 1527193640Sariff info->quality = feeder_rate_quality; 1528193640Sariff info->channels = AFMT_CHANNEL(f->desc->in); 1529193640Sariff 1530193640Sariff f->data = info; 1531193640Sariff 1532193640Sariff ret = z_resampler_setup(f); 1533193640Sariff if (ret != 0) { 1534193640Sariff if (info->z_pcoeff != NULL) 1535193640Sariff free(info->z_pcoeff, M_DEVBUF); 1536193640Sariff if (info->z_delay != NULL) 1537193640Sariff free(info->z_delay, M_DEVBUF); 1538193640Sariff free(info, M_DEVBUF); 1539193640Sariff f->data = NULL; 1540148606Snetchild } 1541193640Sariff 1542193640Sariff return (ret); 154375320Scg} 154475320Scg 154575320Scgstatic int 1546193640Sariffz_resampler_free(struct pcm_feeder *f) 154775320Scg{ 1548193640Sariff struct z_info *info; 154975320Scg 1550193640Sariff info = f->data; 1551167646Sariff if (info != NULL) { 1552193640Sariff if (info->z_pcoeff != NULL) 1553193640Sariff free(info->z_pcoeff, M_DEVBUF); 1554193640Sariff if (info->z_delay != NULL) 1555193640Sariff free(info->z_delay, M_DEVBUF); 1556193640Sariff free(info, M_DEVBUF); 155775320Scg } 1558193640Sariff 155975320Scg f->data = NULL; 1560193640Sariff 1561167646Sariff return (0); 156275320Scg} 156375320Scg 1564193640Sariffstatic uint32_t 1565193640Sariffz_resampler_feed_internal(struct pcm_feeder *f, struct pcm_channel *c, 1566193640Sariff uint8_t *b, uint32_t count, void *source) 1567109547Sorion{ 1568193640Sariff struct z_info *info; 1569193640Sariff int32_t alphadrift, startdrift, reqout, ocount, reqin, align; 1570193640Sariff int32_t fetch, fetched, start, cp; 1571193640Sariff uint8_t *dst; 1572164614Sariff 1573193640Sariff info = f->data; 1574193640Sariff if (info->z_resample == NULL) 1575193640Sariff return (z_feed(f->source, c, b, count, source)); 1576164614Sariff 1577148606Snetchild /* 1578193640Sariff * Calculate sample size alignment and amount of sample output. 1579193640Sariff * We will do everything in sample domain, but at the end we 1580193640Sariff * will jump back to byte domain. 1581148606Snetchild */ 1582193640Sariff align = info->channels * info->bps; 1583193640Sariff ocount = SND_FXDIV(count, align); 1584193640Sariff if (ocount == 0) 1585167646Sariff return (0); 1586193640Sariff 1587148606Snetchild /* 1588193640Sariff * Calculate amount of input samples that is needed to generate 1589193640Sariff * exact amount of output. 1590148606Snetchild */ 1591193640Sariff reqin = z_gy2gx(info, ocount) - z_fetched(info); 1592193640Sariff 1593193640Sariff#ifdef Z_USE_ALPHADRIFT 1594193640Sariff startdrift = info->z_startdrift; 1595193640Sariff alphadrift = info->z_alphadrift; 1596167646Sariff#else 1597193640Sariff startdrift = _Z_GY2GX(info, 0, 1); 1598193640Sariff alphadrift = z_drift(info, startdrift, 1); 1599167646Sariff#endif 1600193640Sariff 1601193640Sariff dst = b; 1602193640Sariff 1603193640Sariff do { 1604193640Sariff if (reqin != 0) { 1605193640Sariff fetch = z_min(z_free(info), reqin); 1606193640Sariff if (fetch == 0) { 1607193640Sariff /* 1608193640Sariff * No more free spaces, so wind enough 1609193640Sariff * samples back to the head of delay line 1610193640Sariff * in byte domain. 1611193640Sariff */ 1612193640Sariff fetched = z_fetched(info); 1613193640Sariff start = z_prev(info, info->z_start, 1614193640Sariff (info->z_size << 1) - 1); 1615193640Sariff cp = (info->z_size << 1) + fetched; 1616193640Sariff z_copy(info->z_delay + (start * align), 1617193640Sariff info->z_delay, cp * align); 1618193640Sariff info->z_start = 1619193640Sariff z_prev(info, info->z_size << 1, 1); 1620193640Sariff info->z_pos = 1621193640Sariff z_next(info, info->z_start, fetched + 1); 1622193640Sariff fetch = z_min(z_free(info), reqin); 1623193640Sariff#ifdef Z_DIAGNOSTIC 1624193640Sariff if (1) { 1625193640Sariff static uint32_t kk = 0; 1626193640Sariff fprintf(stderr, 1627193640Sariff "Buffer Move: " 1628193640Sariff "start=%d fetched=%d cp=%d " 1629193640Sariff "cycle=%u [%u]\r", 1630193640Sariff start, fetched, cp, info->z_cycle, 1631193640Sariff ++kk); 1632193640Sariff } 1633193640Sariff info->z_cycle = 0; 1634167646Sariff#endif 1635193640Sariff } 1636193640Sariff if (fetch != 0) { 1637193640Sariff /* 1638193640Sariff * Fetch in byte domain and jump back 1639193640Sariff * to sample domain. 1640193640Sariff */ 1641193640Sariff fetched = SND_FXDIV(z_feed(f->source, c, 1642193640Sariff info->z_delay + (info->z_pos * align), 1643193640Sariff fetch * align, source), align); 1644193640Sariff /* 1645193640Sariff * Prepare to convert fetched buffer, 1646193640Sariff * or mark us done if we cannot fulfill 1647193640Sariff * the request. 1648193640Sariff */ 1649193640Sariff reqin -= fetched; 1650193640Sariff info->z_pos += fetched; 1651193640Sariff if (fetched != fetch) 1652193640Sariff reqin = 0; 1653193640Sariff } 1654109547Sorion } 1655193640Sariff 1656193640Sariff reqout = z_min(z_gx2gy(info, z_fetched(info)), ocount); 1657193640Sariff if (reqout != 0) { 1658193640Sariff ocount -= reqout; 1659193640Sariff 1660148606Snetchild /* 1661193640Sariff * Drift.. drift.. drift.. 1662193640Sariff * 1663193640Sariff * Notice that there are 2 methods of doing the drift 1664193640Sariff * operations: The former is much cleaner (in a sense 1665194805Sariff * of mathematical readings of my eyes), but slower 1666194805Sariff * due to integer division in z_gy2gx(). Nevertheless, 1667194805Sariff * both should give the same exact accurate drifting 1668194805Sariff * results, so the later is favourable. 1669148606Snetchild */ 1670193640Sariff do { 1671193640Sariff info->z_resample(info, dst); 1672193640Sariff#if 0 1673193640Sariff startdrift = z_gy2gx(info, 1); 1674193640Sariff alphadrift = z_drift(info, startdrift, 1); 1675193640Sariff info->z_start += startdrift; 1676193640Sariff info->z_alpha += alphadrift; 1677193640Sariff#else 1678193640Sariff info->z_alpha += alphadrift; 1679193640Sariff if (info->z_alpha < info->z_gy) 1680193640Sariff info->z_start += startdrift; 1681193640Sariff else { 1682193640Sariff info->z_start += startdrift - 1; 1683193640Sariff info->z_alpha -= info->z_gy; 1684193640Sariff } 1685167646Sariff#endif 1686193640Sariff dst += align; 1687193640Sariff#ifdef Z_DIAGNOSTIC 1688193640Sariff info->z_cycle++; 1689193640Sariff#endif 1690193640Sariff } while (--reqout != 0); 1691148606Snetchild } 1692193640Sariff } while (reqin != 0 && ocount != 0); 1693164614Sariff 1694193640Sariff /* 1695193640Sariff * Back to byte domain.. 1696193640Sariff */ 1697193640Sariff return (dst - b); 1698193640Sariff} 1699164614Sariff 1700193640Sariffstatic int 1701193640Sariffz_resampler_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b, 1702193640Sariff uint32_t count, void *source) 1703193640Sariff{ 1704193640Sariff uint32_t feed, maxfeed, left; 1705164614Sariff 1706193640Sariff /* 1707193640Sariff * Split count to smaller chunks to avoid possible 32bit overflow. 1708193640Sariff */ 1709193640Sariff maxfeed = ((struct z_info *)(f->data))->z_maxfeed; 1710193640Sariff left = count; 1711193640Sariff 1712193640Sariff do { 1713193640Sariff feed = z_resampler_feed_internal(f, c, b, 1714193640Sariff z_min(maxfeed, left), source); 1715193640Sariff b += feed; 1716193640Sariff left -= feed; 1717193640Sariff } while (left != 0 && feed != 0); 1718193640Sariff 1719193640Sariff return (count - left); 1720109547Sorion} 1721109547Sorion 172275320Scgstatic struct pcm_feederdesc feeder_rate_desc[] = { 1723193640Sariff { FEEDER_RATE, 0, 0, 0, 0 }, 1724193640Sariff { 0, 0, 0, 0, 0 }, 172575320Scg}; 1726164614Sariff 172775320Scgstatic kobj_method_t feeder_rate_methods[] = { 1728193640Sariff KOBJMETHOD(feeder_init, z_resampler_init), 1729193640Sariff KOBJMETHOD(feeder_free, z_resampler_free), 1730193640Sariff KOBJMETHOD(feeder_set, z_resampler_set), 1731193640Sariff KOBJMETHOD(feeder_get, z_resampler_get), 1732193640Sariff KOBJMETHOD(feeder_feed, z_resampler_feed), 1733193640Sariff KOBJMETHOD_END 173475320Scg}; 1735164614Sariff 1736193640SariffFEEDER_DECLARE(feeder_rate, NULL); 1737