feeder_rate.c revision 195378
1/*- 2 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27/* 28 * feeder_rate: (Codename: Z Resampler), which means any effort to create 29 * future replacement for this resampler are simply absurd unless 30 * the world decide to add new alphabet after Z. 31 * 32 * FreeBSD bandlimited sinc interpolator, technically based on 33 * "Digital Audio Resampling" by Julius O. Smith III 34 * - http://ccrma.stanford.edu/~jos/resample/ 35 * 36 * The Good: 37 * + all out fixed point integer operations, no soft-float or anything like 38 * that. 39 * + classic polyphase converters with high quality coefficient's polynomial 40 * interpolators. 41 * + fast, faster, or the fastest of its kind. 42 * + compile time configurable. 43 * + etc etc.. 44 * 45 * The Bad: 46 * - The z, z_, and Z_ . Due to mental block (or maybe just 0x7a69), I 47 * couldn't think of anything simpler than that (feeder_rate_xxx is just 48 * too long). Expect possible clashes with other zitizens (any?). 49 */ 50 51#ifdef _KERNEL 52#ifdef HAVE_KERNEL_OPTION_HEADERS 53#include "opt_snd.h" 54#endif 55#include <dev/sound/pcm/sound.h> 56#include <dev/sound/pcm/pcm.h> 57#include "feeder_if.h" 58 59#define SND_USE_FXDIV 60#include "snd_fxdiv_gen.h" 61 62SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/pcm/feeder_rate.c 195378 2009-07-05 18:15:06Z ariff $"); 63#endif 64 65#include "feeder_rate_gen.h" 66 67#if !defined(_KERNEL) && defined(SND_DIAGNOSTIC) 68#undef Z_DIAGNOSTIC 69#define Z_DIAGNOSTIC 1 70#elif defined(_KERNEL) 71#undef Z_DIAGNOSTIC 72#endif 73 74#ifndef Z_QUALITY_DEFAULT 75#define Z_QUALITY_DEFAULT Z_QUALITY_LINEAR 76#endif 77 78#define Z_RESERVOIR 2048 79#define Z_RESERVOIR_MAX 131072 80 81#define Z_SINC_MAX 0x3fffff 82#define Z_SINC_DOWNMAX 48 /* 384000 / 8000 */ 83 84#ifdef _KERNEL 85#define Z_POLYPHASE_MAX 183040 /* 286 taps, 640 phases */ 86#else 87#define Z_POLYPHASE_MAX 1464320 /* 286 taps, 5120 phases */ 88#endif 89 90#define Z_RATE_DEFAULT 48000 91 92#define Z_RATE_MIN FEEDRATE_RATEMIN 93#define Z_RATE_MAX FEEDRATE_RATEMAX 94#define Z_ROUNDHZ FEEDRATE_ROUNDHZ 95#define Z_ROUNDHZ_MIN FEEDRATE_ROUNDHZ_MIN 96#define Z_ROUNDHZ_MAX FEEDRATE_ROUNDHZ_MAX 97 98#define Z_RATE_SRC FEEDRATE_SRC 99#define Z_RATE_DST FEEDRATE_DST 100#define Z_RATE_QUALITY FEEDRATE_QUALITY 101#define Z_RATE_CHANNELS FEEDRATE_CHANNELS 102 103#define Z_PARANOID 1 104 105#define Z_MULTIFORMAT 1 106 107#ifdef _KERNEL 108#undef Z_USE_ALPHADRIFT 109#define Z_USE_ALPHADRIFT 1 110#endif 111 112#define Z_FACTOR_MIN 1 113#define Z_FACTOR_MAX Z_MASK 114#define Z_FACTOR_SAFE(v) (!((v) < Z_FACTOR_MIN || (v) > Z_FACTOR_MAX)) 115 116struct z_info; 117 118typedef void (*z_resampler_t)(struct z_info *, uint8_t *); 119 120struct z_info { 121 int32_t rsrc, rdst; /* original source / destination rates */ 122 int32_t src, dst; /* rounded source / destination rates */ 123 int32_t channels; /* total channels */ 124 int32_t bps; /* bytes-per-sample */ 125 int32_t quality; /* resampling quality */ 126 127 int32_t z_gx, z_gy; /* interpolation / decimation ratio */ 128 int32_t z_alpha; /* output sample time phase / drift */ 129 uint8_t *z_delay; /* FIR delay line / linear buffer */ 130 int32_t *z_coeff; /* FIR coefficients */ 131 int32_t *z_dcoeff; /* FIR coefficients differences */ 132 int32_t *z_pcoeff; /* FIR polyphase coefficients */ 133 int32_t z_scale; /* output scaling */ 134 int32_t z_dx; /* input sample drift increment */ 135 int32_t z_dy; /* output sample drift increment */ 136#ifdef Z_USE_ALPHADRIFT 137 int32_t z_alphadrift; /* alpha drift rate */ 138 int32_t z_startdrift; /* buffer start position drift rate */ 139#endif 140 int32_t z_mask; /* delay line full length mask */ 141 int32_t z_size; /* half width of FIR taps */ 142 int32_t z_full; /* full size of delay line */ 143 int32_t z_alloc; /* largest allocated full size of delay line */ 144 int32_t z_start; /* buffer processing start position */ 145 int32_t z_pos; /* current position for the next feed */ 146#ifdef Z_DIAGNOSTIC 147 uint32_t z_cycle; /* output cycle, purely for statistical */ 148#endif 149 int32_t z_maxfeed; /* maximum feed to avoid 32bit overflow */ 150 151 z_resampler_t z_resample; 152}; 153 154int feeder_rate_min = Z_RATE_MIN; 155int feeder_rate_max = Z_RATE_MAX; 156int feeder_rate_round = Z_ROUNDHZ; 157int feeder_rate_quality = Z_QUALITY_DEFAULT; 158 159static int feeder_rate_polyphase_max = Z_POLYPHASE_MAX; 160 161#ifdef _KERNEL 162static const char feeder_rate_presets[] = FEEDER_RATE_PRESETS; 163SYSCTL_STRING(_hw_snd, OID_AUTO, feeder_rate_presets, CTLFLAG_RD, 164 &feeder_rate_presets, 0, "compile-time rate presets"); 165 166TUNABLE_INT("hw.snd.feeder_rate_min", &feeder_rate_min); 167TUNABLE_INT("hw.snd.feeder_rate_max", &feeder_rate_max); 168TUNABLE_INT("hw.snd.feeder_rate_round", &feeder_rate_round); 169TUNABLE_INT("hw.snd.feeder_rate_quality", &feeder_rate_quality); 170 171TUNABLE_INT("hw.snd.feeder_rate_polyphase_max", &feeder_rate_polyphase_max); 172SYSCTL_INT(_hw_snd, OID_AUTO, feeder_rate_polyphase_max, CTLFLAG_RW, 173 &feeder_rate_polyphase_max, 0, "maximum allowable polyphase entries"); 174 175static int 176sysctl_hw_snd_feeder_rate_min(SYSCTL_HANDLER_ARGS) 177{ 178 int err, val; 179 180 val = feeder_rate_min; 181 err = sysctl_handle_int(oidp, &val, 0, req); 182 183 if (err != 0 || req->newptr == NULL || val == feeder_rate_min) 184 return (err); 185 186 if (!(Z_FACTOR_SAFE(val) && val < feeder_rate_max)) 187 return (EINVAL); 188 189 feeder_rate_min = val; 190 191 return (0); 192} 193SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_min, CTLTYPE_INT | CTLFLAG_RW, 194 0, sizeof(int), sysctl_hw_snd_feeder_rate_min, "I", 195 "minimum allowable rate"); 196 197static int 198sysctl_hw_snd_feeder_rate_max(SYSCTL_HANDLER_ARGS) 199{ 200 int err, val; 201 202 val = feeder_rate_max; 203 err = sysctl_handle_int(oidp, &val, 0, req); 204 205 if (err != 0 || req->newptr == NULL || val == feeder_rate_max) 206 return (err); 207 208 if (!(Z_FACTOR_SAFE(val) && val > feeder_rate_min)) 209 return (EINVAL); 210 211 feeder_rate_max = val; 212 213 return (0); 214} 215SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_max, CTLTYPE_INT | CTLFLAG_RW, 216 0, sizeof(int), sysctl_hw_snd_feeder_rate_max, "I", 217 "maximum allowable rate"); 218 219static int 220sysctl_hw_snd_feeder_rate_round(SYSCTL_HANDLER_ARGS) 221{ 222 int err, val; 223 224 val = feeder_rate_round; 225 err = sysctl_handle_int(oidp, &val, 0, req); 226 227 if (err != 0 || req->newptr == NULL || val == feeder_rate_round) 228 return (err); 229 230 if (val < Z_ROUNDHZ_MIN || val > Z_ROUNDHZ_MAX) 231 return (EINVAL); 232 233 feeder_rate_round = val - (val % Z_ROUNDHZ); 234 235 return (0); 236} 237SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_round, CTLTYPE_INT | CTLFLAG_RW, 238 0, sizeof(int), sysctl_hw_snd_feeder_rate_round, "I", 239 "sample rate converter rounding threshold"); 240 241static int 242sysctl_hw_snd_feeder_rate_quality(SYSCTL_HANDLER_ARGS) 243{ 244 struct snddev_info *d; 245 struct pcm_channel *c; 246 struct pcm_feeder *f; 247 int i, err, val; 248 249 val = feeder_rate_quality; 250 err = sysctl_handle_int(oidp, &val, 0, req); 251 252 if (err != 0 || req->newptr == NULL || val == feeder_rate_quality) 253 return (err); 254 255 if (val < Z_QUALITY_MIN || val > Z_QUALITY_MAX) 256 return (EINVAL); 257 258 feeder_rate_quality = val; 259 260 /* 261 * Traverse all available channels on each device and try to 262 * set resampler quality if and only if it is exist as 263 * part of feeder chains and the channel is idle. 264 */ 265 for (i = 0; pcm_devclass != NULL && 266 i < devclass_get_maxunit(pcm_devclass); i++) { 267 d = devclass_get_softc(pcm_devclass, i); 268 if (!PCM_REGISTERED(d)) 269 continue; 270 PCM_LOCK(d); 271 PCM_WAIT(d); 272 PCM_ACQUIRE(d); 273 CHN_FOREACH(c, d, channels.pcm) { 274 CHN_LOCK(c); 275 f = chn_findfeeder(c, FEEDER_RATE); 276 if (f == NULL || f->data == NULL || CHN_STARTED(c)) { 277 CHN_UNLOCK(c); 278 continue; 279 } 280 (void)FEEDER_SET(f, FEEDRATE_QUALITY, val); 281 CHN_UNLOCK(c); 282 } 283 PCM_RELEASE(d); 284 PCM_UNLOCK(d); 285 } 286 287 return (0); 288} 289SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_quality, CTLTYPE_INT | CTLFLAG_RW, 290 0, sizeof(int), sysctl_hw_snd_feeder_rate_quality, "I", 291 "sample rate converter quality ("__XSTRING(Z_QUALITY_MIN)"=low .. " 292 __XSTRING(Z_QUALITY_MAX)"=high)"); 293#endif /* _KERNEL */ 294 295 296/* 297 * Resampler type. 298 */ 299#define Z_IS_ZOH(i) ((i)->quality == Z_QUALITY_ZOH) 300#define Z_IS_LINEAR(i) ((i)->quality == Z_QUALITY_LINEAR) 301#define Z_IS_SINC(i) ((i)->quality > Z_QUALITY_LINEAR) 302 303/* 304 * Macroses for accurate sample time drift calculations. 305 * 306 * gy2gx : given the amount of output, return the _exact_ required amount of 307 * input. 308 * gx2gy : given the amount of input, return the _maximum_ amount of output 309 * that will be generated. 310 * drift : given the amount of input and output, return the elapsed 311 * sample-time. 312 */ 313#define _Z_GCAST(x) ((uint64_t)(x)) 314 315#if defined(__GNUCLIKE_ASM) && defined(__i386__) 316/* 317 * This is where i386 being beaten to a pulp. Fortunately this function is 318 * rarely being called and if it is, it will decide the best (hopefully) 319 * fastest way to do the division. If we can ensure that everything is dword 320 * aligned, letting the compiler to call udivdi3 to do the division can be 321 * faster compared to this. 322 * 323 * amd64 is the clear winner here, no question about it. 324 */ 325static __inline uint32_t 326Z_DIV(uint64_t v, uint32_t d) 327{ 328 uint32_t hi, lo, quo, rem; 329 330 hi = v >> 32; 331 lo = v & 0xffffffff; 332 333 /* 334 * As much as we can, try to avoid long division like a plague. 335 */ 336 if (hi == 0) 337 quo = lo / d; 338 else 339 __asm("divl %2" 340 : "=a" (quo), "=d" (rem) 341 : "r" (d), "0" (lo), "1" (hi)); 342 343 return (quo); 344} 345#else 346#define Z_DIV(x, y) ((x) / (y)) 347#endif 348 349#define _Z_GY2GX(i, a, v) \ 350 Z_DIV(((_Z_GCAST((i)->z_gx) * (v)) + ((i)->z_gy - (a) - 1)), \ 351 (i)->z_gy) 352 353#define _Z_GX2GY(i, a, v) \ 354 Z_DIV(((_Z_GCAST((i)->z_gy) * (v)) + (a)), (i)->z_gx) 355 356#define _Z_DRIFT(i, x, y) \ 357 ((_Z_GCAST((i)->z_gy) * (x)) - (_Z_GCAST((i)->z_gx) * (y))) 358 359#define z_gy2gx(i, v) _Z_GY2GX(i, (i)->z_alpha, v) 360#define z_gx2gy(i, v) _Z_GX2GY(i, (i)->z_alpha, v) 361#define z_drift(i, x, y) _Z_DRIFT(i, x, y) 362 363/* 364 * Macroses for SINC coefficients table manipulations.. whatever. 365 */ 366#define Z_SINC_COEFF_IDX(i) ((i)->quality - Z_QUALITY_LINEAR - 1) 367 368#define Z_SINC_LEN(i) \ 369 ((int32_t)(((uint64_t)z_coeff_tab[Z_SINC_COEFF_IDX(i)].len << \ 370 Z_SHIFT) / (i)->z_dy)) 371 372#define Z_SINC_BASE_LEN(i) \ 373 ((z_coeff_tab[Z_SINC_COEFF_IDX(i)].len - 1) >> (Z_DRIFT_SHIFT - 1)) 374 375/* 376 * Macroses for linear delay buffer operations. Alignment is not 377 * really necessary since we're not using true circular buffer, but it 378 * will help us guard against possible trespasser. To be honest, 379 * the linear block operations does not need guarding at all due to 380 * accurate drifting! 381 */ 382#define z_align(i, v) ((v) & (i)->z_mask) 383#define z_next(i, o, v) z_align(i, (o) + (v)) 384#define z_prev(i, o, v) z_align(i, (o) - (v)) 385#define z_fetched(i) (z_align(i, (i)->z_pos - (i)->z_start) - 1) 386#define z_free(i) ((i)->z_full - (i)->z_pos) 387 388/* 389 * Macroses for Bla Bla .. :) 390 */ 391#define z_copy(src, dst, sz) (void)memcpy(dst, src, sz) 392#define z_feed(...) FEEDER_FEED(__VA_ARGS__) 393 394static __inline uint32_t 395z_min(uint32_t x, uint32_t y) 396{ 397 398 return ((x < y) ? x : y); 399} 400 401static int32_t 402z_gcd(int32_t x, int32_t y) 403{ 404 int32_t w; 405 406 while (y != 0) { 407 w = x % y; 408 x = y; 409 y = w; 410 } 411 412 return (x); 413} 414 415static int32_t 416z_roundpow2(int32_t v) 417{ 418 int32_t i; 419 420 i = 1; 421 422 /* 423 * Let it overflow at will.. 424 */ 425 while (i > 0 && i < v) 426 i <<= 1; 427 428 return (i); 429} 430 431/* 432 * Zero Order Hold, the worst of the worst, an insult against quality, 433 * but super fast. 434 */ 435static void 436z_feed_zoh(struct z_info *info, uint8_t *dst) 437{ 438#if 0 439 z_copy(info->z_delay + 440 (info->z_start * info->channels * info->bps), dst, 441 info->channels * info->bps); 442#else 443 uint32_t cnt; 444 uint8_t *src; 445 446 cnt = info->channels * info->bps; 447 src = info->z_delay + (info->z_start * cnt); 448 449 /* 450 * This is a bit faster than doing bcopy() since we're dealing 451 * with possible unaligned samples. 452 */ 453 do { 454 *dst++ = *src++; 455 } while (--cnt != 0); 456#endif 457} 458 459/* 460 * Linear Interpolation. This at least sounds better (perceptually) and fast, 461 * but without any proper filtering which means aliasing still exist and 462 * could become worst with a right sample. Interpolation centered within 463 * Z_LINEAR_ONE between the present and previous sample and everything is 464 * done with simple 32bit scaling arithmetic. 465 */ 466#define Z_DECLARE_LINEAR(SIGN, BIT, ENDIAN) \ 467static void \ 468z_feed_linear_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \ 469{ \ 470 int32_t z; \ 471 intpcm_t x, y; \ 472 uint32_t ch; \ 473 uint8_t *sx, *sy; \ 474 \ 475 z = ((uint32_t)info->z_alpha * info->z_dx) >> Z_LINEAR_UNSHIFT; \ 476 \ 477 sx = info->z_delay + (info->z_start * info->channels * \ 478 PCM_##BIT##_BPS); \ 479 sy = sx - (info->channels * PCM_##BIT##_BPS); \ 480 \ 481 ch = info->channels; \ 482 \ 483 do { \ 484 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(sx); \ 485 y = _PCM_READ_##SIGN##BIT##_##ENDIAN(sy); \ 486 x = Z_LINEAR_INTERPOLATE_##BIT(z, x, y); \ 487 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x); \ 488 sx += PCM_##BIT##_BPS; \ 489 sy += PCM_##BIT##_BPS; \ 490 dst += PCM_##BIT##_BPS; \ 491 } while (--ch != 0); \ 492} 493 494/* 495 * Userland clipping diagnostic check, not enabled in kernel compilation. 496 * While doing sinc interpolation, unrealistic samples like full scale sine 497 * wav will clip, but for other things this will not make any noise at all. 498 * Everybody should learn how to normalized perceived loudness of their own 499 * music/sounds/samples (hint: ReplayGain). 500 */ 501#ifdef Z_DIAGNOSTIC 502#define Z_CLIP_CHECK(v, BIT) do { \ 503 if ((v) > PCM_S##BIT##_MAX) { \ 504 fprintf(stderr, "Overflow: v=%jd, max=%jd\n", \ 505 (intmax_t)(v), (intmax_t)PCM_S##BIT##_MAX); \ 506 } else if ((v) < PCM_S##BIT##_MIN) { \ 507 fprintf(stderr, "Underflow: v=%jd, min=%jd\n", \ 508 (intmax_t)(v), (intmax_t)PCM_S##BIT##_MIN); \ 509 } \ 510} while (0) 511#else 512#define Z_CLIP_CHECK(...) 513#endif 514 515#define Z_CLAMP(v, BIT) \ 516 (((v) > PCM_S##BIT##_MAX) ? PCM_S##BIT##_MAX : \ 517 (((v) < PCM_S##BIT##_MIN) ? PCM_S##BIT##_MIN : (v))) 518 519/* 520 * Sine Cardinal (SINC) Interpolation. Scaling is done in 64 bit, so 521 * there's no point to hold the plate any longer. All samples will be 522 * shifted to a full 32 bit, scaled and restored during write for 523 * maximum dynamic range (only for downsampling). 524 */ 525#define _Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, adv) \ 526 c += z >> Z_SHIFT; \ 527 z &= Z_MASK; \ 528 coeff = Z_COEFF_INTERPOLATE(z, z_coeff[c], z_dcoeff[c]); \ 529 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \ 530 v += Z_NORM_##BIT((intpcm64_t)x * coeff); \ 531 z += info->z_dy; \ 532 p adv##= info->channels * PCM_##BIT##_BPS 533 534/* 535 * XXX GCC4 optimization is such a !@#$%, need manual unrolling. 536 */ 537#if defined(__GNUC__) && __GNUC__ >= 4 538#define Z_SINC_ACCUMULATE(...) do { \ 539 _Z_SINC_ACCUMULATE(__VA_ARGS__); \ 540 _Z_SINC_ACCUMULATE(__VA_ARGS__); \ 541} while (0) 542#define Z_SINC_ACCUMULATE_DECR 2 543#else 544#define Z_SINC_ACCUMULATE(...) do { \ 545 _Z_SINC_ACCUMULATE(__VA_ARGS__); \ 546} while (0) 547#define Z_SINC_ACCUMULATE_DECR 1 548#endif 549 550#define Z_DECLARE_SINC(SIGN, BIT, ENDIAN) \ 551static void \ 552z_feed_sinc_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \ 553{ \ 554 intpcm64_t v; \ 555 intpcm_t x; \ 556 uint8_t *p; \ 557 int32_t coeff, z, *z_coeff, *z_dcoeff; \ 558 uint32_t c, center, ch, i; \ 559 \ 560 z_coeff = info->z_coeff; \ 561 z_dcoeff = info->z_dcoeff; \ 562 center = z_prev(info, info->z_start, info->z_size); \ 563 ch = info->channels * PCM_##BIT##_BPS; \ 564 dst += ch; \ 565 \ 566 do { \ 567 dst -= PCM_##BIT##_BPS; \ 568 ch -= PCM_##BIT##_BPS; \ 569 v = 0; \ 570 z = info->z_alpha * info->z_dx; \ 571 c = 0; \ 572 p = info->z_delay + (z_next(info, center, 1) * \ 573 info->channels * PCM_##BIT##_BPS) + ch; \ 574 for (i = info->z_size; i != 0; i -= Z_SINC_ACCUMULATE_DECR) \ 575 Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, +); \ 576 z = info->z_dy - (info->z_alpha * info->z_dx); \ 577 c = 0; \ 578 p = info->z_delay + (center * info->channels * \ 579 PCM_##BIT##_BPS) + ch; \ 580 for (i = info->z_size; i != 0; i -= Z_SINC_ACCUMULATE_DECR) \ 581 Z_SINC_ACCUMULATE(SIGN, BIT, ENDIAN, -); \ 582 if (info->z_scale != Z_ONE) \ 583 v = Z_SCALE_##BIT(v, info->z_scale); \ 584 else \ 585 v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \ 586 Z_CLIP_CHECK(v, BIT); \ 587 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \ 588 } while (ch != 0); \ 589} 590 591#define Z_DECLARE_SINC_POLYPHASE(SIGN, BIT, ENDIAN) \ 592static void \ 593z_feed_sinc_polyphase_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \ 594{ \ 595 intpcm64_t v; \ 596 intpcm_t x; \ 597 uint8_t *p; \ 598 int32_t ch, i, start, *z_pcoeff; \ 599 \ 600 ch = info->channels * PCM_##BIT##_BPS; \ 601 dst += ch; \ 602 start = z_prev(info, info->z_start, (info->z_size << 1) - 1) * ch; \ 603 \ 604 do { \ 605 dst -= PCM_##BIT##_BPS; \ 606 ch -= PCM_##BIT##_BPS; \ 607 v = 0; \ 608 p = info->z_delay + start + ch; \ 609 z_pcoeff = info->z_pcoeff + \ 610 ((info->z_alpha * info->z_size) << 1); \ 611 for (i = info->z_size; i != 0; i--) { \ 612 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \ 613 v += Z_NORM_##BIT((intpcm64_t)x * *z_pcoeff); \ 614 z_pcoeff++; \ 615 p += info->channels * PCM_##BIT##_BPS; \ 616 x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \ 617 v += Z_NORM_##BIT((intpcm64_t)x * *z_pcoeff); \ 618 z_pcoeff++; \ 619 p += info->channels * PCM_##BIT##_BPS; \ 620 } \ 621 if (info->z_scale != Z_ONE) \ 622 v = Z_SCALE_##BIT(v, info->z_scale); \ 623 else \ 624 v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \ 625 Z_CLIP_CHECK(v, BIT); \ 626 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \ 627 } while (ch != 0); \ 628} 629 630#define Z_DECLARE(SIGN, BIT, ENDIAN) \ 631 Z_DECLARE_LINEAR(SIGN, BIT, ENDIAN) \ 632 Z_DECLARE_SINC(SIGN, BIT, ENDIAN) \ 633 Z_DECLARE_SINC_POLYPHASE(SIGN, BIT, ENDIAN) 634 635#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 636Z_DECLARE(S, 16, LE) 637Z_DECLARE(S, 32, LE) 638#endif 639#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 640Z_DECLARE(S, 16, BE) 641Z_DECLARE(S, 32, BE) 642#endif 643#ifdef SND_FEEDER_MULTIFORMAT 644Z_DECLARE(S, 8, NE) 645Z_DECLARE(S, 24, LE) 646Z_DECLARE(S, 24, BE) 647Z_DECLARE(U, 8, NE) 648Z_DECLARE(U, 16, LE) 649Z_DECLARE(U, 24, LE) 650Z_DECLARE(U, 32, LE) 651Z_DECLARE(U, 16, BE) 652Z_DECLARE(U, 24, BE) 653Z_DECLARE(U, 32, BE) 654#endif 655 656enum { 657 Z_RESAMPLER_ZOH, 658 Z_RESAMPLER_LINEAR, 659 Z_RESAMPLER_SINC, 660 Z_RESAMPLER_SINC_POLYPHASE, 661 Z_RESAMPLER_LAST 662}; 663 664#define Z_RESAMPLER_IDX(i) \ 665 (Z_IS_SINC(i) ? Z_RESAMPLER_SINC : (i)->quality) 666 667#define Z_RESAMPLER_ENTRY(SIGN, BIT, ENDIAN) \ 668 { \ 669 AFMT_##SIGN##BIT##_##ENDIAN, \ 670 { \ 671 [Z_RESAMPLER_ZOH] = z_feed_zoh, \ 672 [Z_RESAMPLER_LINEAR] = z_feed_linear_##SIGN##BIT##ENDIAN, \ 673 [Z_RESAMPLER_SINC] = z_feed_sinc_##SIGN##BIT##ENDIAN, \ 674 [Z_RESAMPLER_SINC_POLYPHASE] = \ 675 z_feed_sinc_polyphase_##SIGN##BIT##ENDIAN \ 676 } \ 677 } 678 679static const struct { 680 uint32_t format; 681 z_resampler_t resampler[Z_RESAMPLER_LAST]; 682} z_resampler_tab[] = { 683#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 684 Z_RESAMPLER_ENTRY(S, 16, LE), 685 Z_RESAMPLER_ENTRY(S, 32, LE), 686#endif 687#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 688 Z_RESAMPLER_ENTRY(S, 16, BE), 689 Z_RESAMPLER_ENTRY(S, 32, BE), 690#endif 691#ifdef SND_FEEDER_MULTIFORMAT 692 Z_RESAMPLER_ENTRY(S, 8, NE), 693 Z_RESAMPLER_ENTRY(S, 24, LE), 694 Z_RESAMPLER_ENTRY(S, 24, BE), 695 Z_RESAMPLER_ENTRY(U, 8, NE), 696 Z_RESAMPLER_ENTRY(U, 16, LE), 697 Z_RESAMPLER_ENTRY(U, 24, LE), 698 Z_RESAMPLER_ENTRY(U, 32, LE), 699 Z_RESAMPLER_ENTRY(U, 16, BE), 700 Z_RESAMPLER_ENTRY(U, 24, BE), 701 Z_RESAMPLER_ENTRY(U, 32, BE), 702#endif 703}; 704 705#define Z_RESAMPLER_TAB_SIZE \ 706 ((int32_t)(sizeof(z_resampler_tab) / sizeof(z_resampler_tab[0]))) 707 708static void 709z_resampler_reset(struct z_info *info) 710{ 711 712 info->src = info->rsrc - (info->rsrc % ((feeder_rate_round > 0 && 713 info->rsrc > feeder_rate_round) ? feeder_rate_round : 1)); 714 info->dst = info->rdst - (info->rdst % ((feeder_rate_round > 0 && 715 info->rdst > feeder_rate_round) ? feeder_rate_round : 1)); 716 info->z_gx = 1; 717 info->z_gy = 1; 718 info->z_alpha = 0; 719 info->z_resample = NULL; 720 info->z_size = 1; 721 info->z_coeff = NULL; 722 info->z_dcoeff = NULL; 723 if (info->z_pcoeff != NULL) { 724 free(info->z_pcoeff, M_DEVBUF); 725 info->z_pcoeff = NULL; 726 } 727 info->z_scale = Z_ONE; 728 info->z_dx = Z_FULL_ONE; 729 info->z_dy = Z_FULL_ONE; 730#ifdef Z_DIAGNOSTIC 731 info->z_cycle = 0; 732#endif 733 if (info->quality < Z_QUALITY_MIN) 734 info->quality = Z_QUALITY_MIN; 735 else if (info->quality > Z_QUALITY_MAX) 736 info->quality = Z_QUALITY_MAX; 737} 738 739#ifdef Z_PARANOID 740static int32_t 741z_resampler_sinc_len(struct z_info *info) 742{ 743 int32_t c, z, len, lmax; 744 745 if (!Z_IS_SINC(info)) 746 return (1); 747 748 /* 749 * A rather careful (or useless) way to calculate filter length. 750 * Z_SINC_LEN() itself is accurate enough to do its job. Extra 751 * sanity checking is not going to hurt though.. 752 */ 753 c = 0; 754 z = info->z_dy; 755 len = 0; 756 lmax = z_coeff_tab[Z_SINC_COEFF_IDX(info)].len; 757 758 do { 759 c += z >> Z_SHIFT; 760 z &= Z_MASK; 761 z += info->z_dy; 762 } while (c < lmax && ++len > 0); 763 764 if (len != Z_SINC_LEN(info)) { 765#ifdef _KERNEL 766 printf("%s(): sinc l=%d != Z_SINC_LEN=%d\n", 767 __func__, len, Z_SINC_LEN(info)); 768#else 769 fprintf(stderr, "%s(): sinc l=%d != Z_SINC_LEN=%d\n", 770 __func__, len, Z_SINC_LEN(info)); 771 return (-1); 772#endif 773 } 774 775 return (len); 776} 777#else 778#define z_resampler_sinc_len(i) (Z_IS_SINC(i) ? Z_SINC_LEN(i) : 1) 779#endif 780 781#define Z_POLYPHASE_COEFF_SHIFT 0 782 783/* 784 * Pick suitable polynomial interpolators based on filter oversampled ratio 785 * (2 ^ Z_DRIFT_SHIFT). 786 */ 787#if !(defined(Z_COEFF_INTERP_ZOH) || defined(Z_COEFF_INTERP_LINEAR) || \ 788 defined(Z_COEFF_INTERP_QUADRATIC) || defined(Z_COEFF_INTERP_HERMITE) || \ 789 defined(Z_COEFF_INTER_BSPLINE) || defined(Z_COEFF_INTERP_OPT32X) || \ 790 defined(Z_COEFF_INTERP_OPT16X) || defined(Z_COEFF_INTERP_OPT8X) || \ 791 defined(Z_COEFF_INTERP_OPT4X) || defined(Z_COEFF_INTERP_OPT2X)) 792#if Z_DRIFT_SHIFT >= 12 793#define Z_COEFF_INTERP_LINEAR 1 794#elif Z_DRIFT_SHIFT >= 8 795#define Z_COEFF_INTERP_QUADRATIC 1 796#elif Z_DRIFT_SHIFT >= 5 797#define Z_COEFF_INTERP_OPT32X 1 798#elif Z_DRIFT_SHIFT == 4 799#define Z_COEFF_INTERP_OPT16X 1 800#elif Z_DRIFT_SHIFT == 3 801#define Z_COEFF_INTERP_OPT8X 1 802#elif Z_DRIFT_SHIFT == 2 803#define Z_COEFF_INTERP_OPT4X 1 804#elif Z_DRIFT_SHIFT == 1 805#define Z_COEFF_INTERP_OPT2X 1 806#else 807#error "Z_DRIFT_SHIFT screwed!" 808#endif 809#endif 810 811/* 812 * In classic polyphase mode, the actual coefficients for each phases need to 813 * be calculated based on default prototype filters. For highly oversampled 814 * filter, linear or quadradatic interpolator should be enough. Anything less 815 * than that require 'special' interpolators to reduce interpolation errors. 816 * 817 * "Polynomial Interpolators for High-Quality Resampling of Oversampled Audio" 818 * by Olli Niemitalo 819 * - http://www.student.oulu.fi/~oniemita/dsp/deip.pdf 820 * 821 */ 822static int32_t 823z_coeff_interpolate(int32_t z, int32_t *z_coeff) 824{ 825 int32_t coeff; 826#if defined(Z_COEFF_INTERP_ZOH) 827 828 /* 1-point, 0th-order (Zero Order Hold) */ 829 z = z; 830 coeff = z_coeff[0]; 831#elif defined(Z_COEFF_INTERP_LINEAR) 832 int32_t zl0, zl1; 833 834 /* 2-point, 1st-order Linear */ 835 zl0 = z_coeff[0]; 836 zl1 = z_coeff[1] - z_coeff[0]; 837 838 coeff = (((int64_t)zl1 * z) >> Z_SHIFT) + zl0; 839#elif defined(Z_COEFF_INTERP_QUADRATIC) 840 int32_t zq0, zq1, zq2; 841 842 /* 3-point, 2nd-order Quadratic */ 843 zq0 = z_coeff[0]; 844 zq1 = z_coeff[1] - z_coeff[-1]; 845 zq2 = z_coeff[1] + z_coeff[-1] - (z_coeff[0] << 1); 846 847 coeff = ((((((int64_t)zq2 * z) >> Z_SHIFT) + 848 zq1) * z) >> (Z_SHIFT + 1)) + zq0; 849#elif defined(Z_COEFF_INTERP_HERMITE) 850 int32_t zh0, zh1, zh2, zh3; 851 852 /* 4-point, 3rd-order Hermite */ 853 zh0 = z_coeff[0]; 854 zh1 = z_coeff[1] - z_coeff[-1]; 855 zh2 = (z_coeff[-1] << 1) - (z_coeff[0] * 5) + (z_coeff[1] << 2) - 856 z_coeff[2]; 857 zh3 = z_coeff[2] - z_coeff[-1] + ((z_coeff[0] - z_coeff[1]) * 3); 858 859 coeff = (((((((((int64_t)zh3 * z) >> Z_SHIFT) + 860 zh2) * z) >> Z_SHIFT) + zh1) * z) >> (Z_SHIFT + 1)) + zh0; 861#elif defined(Z_COEFF_INTERP_BSPLINE) 862 int32_t zb0, zb1, zb2, zb3; 863 864 /* 4-point, 3rd-order B-Spline */ 865 zb0 = (((int64_t)z_coeff[0] << 2) + z_coeff[-1] + z_coeff[1]) / 3; 866 zb1 = z_coeff[1] - z_coeff[-1]; 867 zb2 = z_coeff[-1] + z_coeff[1] - (z_coeff[0] << 1); 868 zb3 = (((z_coeff[0] - z_coeff[1]) * 3) + z_coeff[2] - z_coeff[-1]) / 3; 869 870 coeff = ((((((((((int64_t)zb3 * z) >> Z_SHIFT) + 871 zb2) * z) >> Z_SHIFT) + zb1) * z) >> Z_SHIFT) + zb0) >> 1; 872#elif defined(Z_COEFF_INTERP_OPT32X) 873 int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3; 874 int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5; 875 876 /* 6-point, 5th-order Optimal 32x */ 877 zoz = z - (Z_ONE >> 1); 878 zoe1 = z_coeff[1] + z_coeff[0]; 879 zoe2 = z_coeff[2] + z_coeff[-1]; 880 zoe3 = z_coeff[3] + z_coeff[-2]; 881 zoo1 = z_coeff[1] - z_coeff[0]; 882 zoo2 = z_coeff[2] - z_coeff[-1]; 883 zoo3 = z_coeff[3] - z_coeff[-2]; 884 885 zoc0 = ((0x1ac2260dLL * zoe1) >> 30) + 886 ((0x0526cdcaLL * zoe2) >> 30) + ((0x00170c29LL * zoe3) >> 30); 887 zoc1 = ((0x14f8a49aLL * zoo1) >> 30) + 888 ((0x0d6d1109LL * zoo2) >> 30) + ((0x008cd4dcLL * zoo3) >> 30); 889 zoc2 = ((-0x0d3e94a4LL * zoe1) >> 30) + 890 ((0x0bddded4LL * zoe2) >> 30) + ((0x0160b5d0LL * zoe3) >> 30); 891 zoc3 = ((-0x0de10cc4LL * zoo1) >> 30) + 892 ((0x019b2a7dLL * zoo2) >> 30) + ((0x01cfe914LL * zoo3) >> 30); 893 zoc4 = ((0x02aa12d7LL * zoe1) >> 30) + 894 ((-0x03ff1bb3LL * zoe2) >> 30) + ((0x015508ddLL * zoe3) >> 30); 895 zoc5 = ((0x051d29e5LL * zoo1) >> 30) + 896 ((-0x028e7647LL * zoo2) >> 30) + ((0x0082d81aLL * zoo3) >> 30); 897 898 coeff = (((((((((((((((int64_t)zoc5 * zoz) >> Z_SHIFT) + 899 zoc4) * zoz) >> Z_SHIFT) + zoc3) * zoz) >> Z_SHIFT) + 900 zoc2) * zoz) >> Z_SHIFT) + zoc1) * zoz) >> Z_SHIFT) + zoc0; 901#elif defined(Z_COEFF_INTERP_OPT16X) 902 int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3; 903 int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5; 904 905 /* 6-point, 5th-order Optimal 16x */ 906 zoz = z - (Z_ONE >> 1); 907 zoe1 = z_coeff[1] + z_coeff[0]; 908 zoe2 = z_coeff[2] + z_coeff[-1]; 909 zoe3 = z_coeff[3] + z_coeff[-2]; 910 zoo1 = z_coeff[1] - z_coeff[0]; 911 zoo2 = z_coeff[2] - z_coeff[-1]; 912 zoo3 = z_coeff[3] - z_coeff[-2]; 913 914 zoc0 = ((0x1ac2260dLL * zoe1) >> 30) + 915 ((0x0526cdcaLL * zoe2) >> 30) + ((0x00170c29LL * zoe3) >> 30); 916 zoc1 = ((0x14f8a49aLL * zoo1) >> 30) + 917 ((0x0d6d1109LL * zoo2) >> 30) + ((0x008cd4dcLL * zoo3) >> 30); 918 zoc2 = ((-0x0d3e94a4LL * zoe1) >> 30) + 919 ((0x0bddded4LL * zoe2) >> 30) + ((0x0160b5d0LL * zoe3) >> 30); 920 zoc3 = ((-0x0de10cc4LL * zoo1) >> 30) + 921 ((0x019b2a7dLL * zoo2) >> 30) + ((0x01cfe914LL * zoo3) >> 30); 922 zoc4 = ((0x02aa12d7LL * zoe1) >> 30) + 923 ((-0x03ff1bb3LL * zoe2) >> 30) + ((0x015508ddLL * zoe3) >> 30); 924 zoc5 = ((0x051d29e5LL * zoo1) >> 30) + 925 ((-0x028e7647LL * zoo2) >> 30) + ((0x0082d81aLL * zoo3) >> 30); 926 927 coeff = (((((((((((((((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; 933 934 /* 6-point, 5th-order Optimal 8x */ 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]; 942 943 zoc0 = ((0x1aa9b47dLL * zoe1) >> 30) + 944 ((0x053d9944LL * zoe2) >> 30) + ((0x0018b23fLL * zoe3) >> 30); 945 zoc1 = ((0x14a104d1LL * zoo1) >> 30) + 946 ((0x0d7d2504LL * zoo2) >> 30) + ((0x0094b599LL * zoo3) >> 30); 947 zoc2 = ((-0x0d22530bLL * zoe1) >> 30) + 948 ((0x0bb37a2cLL * zoe2) >> 30) + ((0x016ed8e0LL * zoe3) >> 30); 949 zoc3 = ((-0x0d744b1cLL * zoo1) >> 30) + 950 ((0x01649591LL * zoo2) >> 30) + ((0x01dae93aLL * zoo3) >> 30); 951 zoc4 = ((0x02a7ee1bLL * zoe1) >> 30) + 952 ((-0x03fbdb24LL * zoe2) >> 30) + ((0x0153ed07LL * zoe3) >> 30); 953 zoc5 = ((0x04cf9b6cLL * zoo1) >> 30) + 954 ((-0x0266b378LL * zoo2) >> 30) + ((0x007a7c26LL * zoo3) >> 30); 955 956 coeff = (((((((((((((((int64_t)zoc5 * zoz) >> Z_SHIFT) + 957 zoc4) * zoz) >> Z_SHIFT) + zoc3) * zoz) >> Z_SHIFT) + 958 zoc2) * zoz) >> Z_SHIFT) + zoc1) * zoz) >> Z_SHIFT) + zoc0; 959#elif defined(Z_COEFF_INTERP_OPT4X) 960 int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3; 961 int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5; 962 963 /* 6-point, 5th-order Optimal 4x */ 964 zoz = z - (Z_ONE >> 1); 965 zoe1 = z_coeff[1] + z_coeff[0]; 966 zoe2 = z_coeff[2] + z_coeff[-1]; 967 zoe3 = z_coeff[3] + z_coeff[-2]; 968 zoo1 = z_coeff[1] - z_coeff[0]; 969 zoo2 = z_coeff[2] - z_coeff[-1]; 970 zoo3 = z_coeff[3] - z_coeff[-2]; 971 972 zoc0 = ((0x1a8eda43LL * zoe1) >> 30) + 973 ((0x0556ee38LL * zoe2) >> 30) + ((0x001a3784LL * zoe3) >> 30); 974 zoc1 = ((0x143d863eLL * zoo1) >> 30) + 975 ((0x0d910e36LL * zoo2) >> 30) + ((0x009ca889LL * zoo3) >> 30); 976 zoc2 = ((-0x0d026821LL * zoe1) >> 30) + 977 ((0x0b837773LL * zoe2) >> 30) + ((0x017ef0c6LL * zoe3) >> 30); 978 zoc3 = ((-0x0cef1502LL * zoo1) >> 30) + 979 ((0x01207a8eLL * zoo2) >> 30) + ((0x01e936dbLL * zoo3) >> 30); 980 zoc4 = ((0x029fe643LL * zoe1) >> 30) + 981 ((-0x03ef3fc8LL * zoe2) >> 30) + ((0x014f5923LL * zoe3) >> 30); 982 zoc5 = ((0x043a9d08LL * zoo1) >> 30) + 983 ((-0x02154febLL * zoo2) >> 30) + ((0x00670dbdLL * zoo3) >> 30); 984 985 coeff = (((((((((((((((int64_t)zoc5 * zoz) >> Z_SHIFT) + 986 zoc4) * zoz) >> Z_SHIFT) + zoc3) * zoz) >> Z_SHIFT) + 987 zoc2) * zoz) >> Z_SHIFT) + zoc1) * zoz) >> Z_SHIFT) + zoc0; 988#elif defined(Z_COEFF_INTERP_OPT2X) 989 int32_t zoz, zoe1, zoe2, zoe3, zoo1, zoo2, zoo3; 990 int32_t zoc0, zoc1, zoc2, zoc3, zoc4, zoc5; 991 992 /* 6-point, 5th-order Optimal 2x */ 993 zoz = z - (Z_ONE >> 1); 994 zoe1 = z_coeff[1] + z_coeff[0]; 995 zoe2 = z_coeff[2] + z_coeff[-1]; 996 zoe3 = z_coeff[3] + z_coeff[-2]; 997 zoo1 = z_coeff[1] - z_coeff[0]; 998 zoo2 = z_coeff[2] - z_coeff[-1]; 999 zoo3 = z_coeff[3] - z_coeff[-2]; 1000 1001 zoc0 = ((0x19edb6fdLL * zoe1) >> 30) + 1002 ((0x05ebd062LL * zoe2) >> 30) + ((0x00267881LL * zoe3) >> 30); 1003 zoc1 = ((0x1223af76LL * zoo1) >> 30) + 1004 ((0x0de3dd6bLL * zoo2) >> 30) + ((0x00d683cdLL * zoo3) >> 30); 1005 zoc2 = ((-0x0c3ee068LL * zoe1) >> 30) + 1006 ((0x0a5c3769LL * zoe2) >> 30) + ((0x01e2aceaLL * zoe3) >> 30); 1007 zoc3 = ((-0x0a8ab614LL * zoo1) >> 30) + 1008 ((-0x0019522eLL * zoo2) >> 30) + ((0x022cefc7LL * zoo3) >> 30); 1009 zoc4 = ((0x0276187dLL * zoe1) >> 30) + 1010 ((-0x03a801e8LL * zoe2) >> 30) + ((0x0131d935LL * zoe3) >> 30); 1011 zoc5 = ((0x02c373f5LL * zoo1) >> 30) + 1012 ((-0x01275f83LL * zoo2) >> 30) + ((0x0018ee79LL * zoo3) >> 30); 1013 1014 coeff = (((((((((((((((int64_t)zoc5 * zoz) >> Z_SHIFT) + 1015 zoc4) * zoz) >> Z_SHIFT) + zoc3) * zoz) >> Z_SHIFT) + 1016 zoc2) * zoz) >> Z_SHIFT) + zoc1) * zoz) >> Z_SHIFT) + zoc0; 1017#else 1018#error "Interpolation type screwed!" 1019#endif 1020 1021#if Z_POLYPHASE_COEFF_SHIFT > 0 1022 coeff = Z_RSHIFT(coeff, Z_POLYPHASE_COEFF_SHIFT); 1023#endif 1024 return (coeff); 1025} 1026 1027static int 1028z_resampler_build_polyphase(struct z_info *info) 1029{ 1030 int32_t alpha, c, i, z, idx; 1031 1032 /* Let this be here first. */ 1033 if (info->z_pcoeff != NULL) { 1034 free(info->z_pcoeff, M_DEVBUF); 1035 info->z_pcoeff = NULL; 1036 } 1037 1038 if (feeder_rate_polyphase_max < 1) 1039 return (ENOTSUP); 1040 1041 if (((int64_t)info->z_size * info->z_gy * 2) > 1042 feeder_rate_polyphase_max) { 1043#ifndef _KERNEL 1044 fprintf(stderr, "Polyphase entries exceed: [%d/%d] %jd > %d\n", 1045 info->z_gx, info->z_gy, 1046 (intmax_t)info->z_size * info->z_gy * 2, 1047 feeder_rate_polyphase_max); 1048#endif 1049 return (E2BIG); 1050 } 1051 1052 info->z_pcoeff = malloc(sizeof(int32_t) * 1053 info->z_size * info->z_gy * 2, M_DEVBUF, M_NOWAIT | M_ZERO); 1054 if (info->z_pcoeff == NULL) 1055 return (ENOMEM); 1056 1057 for (alpha = 0; alpha < info->z_gy; alpha++) { 1058 z = alpha * info->z_dx; 1059 c = 0; 1060 for (i = info->z_size; i != 0; i--) { 1061 c += z >> Z_SHIFT; 1062 z &= Z_MASK; 1063 idx = (alpha * info->z_size * 2) + 1064 (info->z_size * 2) - i; 1065 info->z_pcoeff[idx] = 1066 z_coeff_interpolate(z, info->z_coeff + c); 1067 z += info->z_dy; 1068 } 1069 z = info->z_dy - (alpha * info->z_dx); 1070 c = 0; 1071 for (i = info->z_size; i != 0; i--) { 1072 c += z >> Z_SHIFT; 1073 z &= Z_MASK; 1074 idx = (alpha * info->z_size * 2) + i - 1; 1075 info->z_pcoeff[idx] = 1076 z_coeff_interpolate(z, info->z_coeff + c); 1077 z += info->z_dy; 1078 } 1079 } 1080 1081#ifndef _KERNEL 1082 fprintf(stderr, "Polyphase: [%d/%d] %d entries\n", 1083 info->z_gx, info->z_gy, info->z_size * info->z_gy * 2); 1084#endif 1085 1086 return (0); 1087} 1088 1089static int 1090z_resampler_setup(struct pcm_feeder *f) 1091{ 1092 struct z_info *info; 1093 int64_t gy2gx_max, gx2gy_max; 1094 uint32_t format; 1095 int32_t align, i, z_scale; 1096 int adaptive; 1097 1098 info = f->data; 1099 z_resampler_reset(info); 1100 1101 if (info->src == info->dst) 1102 return (0); 1103 1104 /* Shrink by greatest common divisor. */ 1105 i = z_gcd(info->src, info->dst); 1106 info->z_gx = info->src / i; 1107 info->z_gy = info->dst / i; 1108 1109 /* Too big, or too small. Bail out. */ 1110 if (!(Z_FACTOR_SAFE(info->z_gx) && Z_FACTOR_SAFE(info->z_gy))) 1111 return (EINVAL); 1112 1113 format = f->desc->in; 1114 adaptive = 0; 1115 z_scale = 0; 1116 1117 /* 1118 * Setup everything: filter length, conversion factor, etc. 1119 */ 1120 if (Z_IS_SINC(info)) { 1121 /* 1122 * Downsampling, or upsampling scaling factor. As long as the 1123 * factor can be represented by a fraction of 1 << Z_SHIFT, 1124 * we're pretty much in business. Scaling is not needed for 1125 * upsampling, so we just slap Z_ONE there. 1126 */ 1127 if (info->z_gx > info->z_gy) 1128 /* 1129 * If the downsampling ratio is beyond sanity, 1130 * enable semi-adaptive mode. Although handling 1131 * extreme ratio is possible, the result of the 1132 * conversion is just pointless, unworthy, 1133 * nonsensical noises, etc. 1134 */ 1135 if ((info->z_gx / info->z_gy) > Z_SINC_DOWNMAX) 1136 z_scale = Z_ONE / Z_SINC_DOWNMAX; 1137 else 1138 z_scale = ((uint64_t)info->z_gy << Z_SHIFT) / 1139 info->z_gx; 1140 else 1141 z_scale = Z_ONE; 1142 1143 /* 1144 * This is actually impossible, unless anything above 1145 * overflow. 1146 */ 1147 if (z_scale < 1) 1148 return (E2BIG); 1149 1150 /* 1151 * Calculate sample time/coefficients index drift. It is 1152 * a constant for upsampling, but downsampling require 1153 * heavy duty filtering with possible too long filters. 1154 * If anything goes wrong, revisit again and enable 1155 * adaptive mode. 1156 */ 1157z_setup_adaptive_sinc: 1158 if (info->z_pcoeff != NULL) { 1159 free(info->z_pcoeff, M_DEVBUF); 1160 info->z_pcoeff = NULL; 1161 } 1162 1163 if (adaptive == 0) { 1164 info->z_dy = z_scale << Z_DRIFT_SHIFT; 1165 if (info->z_dy < 1) 1166 return (E2BIG); 1167 info->z_scale = z_scale; 1168 } else { 1169 info->z_dy = Z_FULL_ONE; 1170 info->z_scale = Z_ONE; 1171 } 1172 1173#if 0 1174#define Z_SCALE_DIV 10000 1175#define Z_SCALE_LIMIT(s, v) \ 1176 ((((uint64_t)(s) * (v)) + (Z_SCALE_DIV >> 1)) / Z_SCALE_DIV) 1177 1178 info->z_scale = Z_SCALE_LIMIT(info->z_scale, 9780); 1179#endif 1180 1181 /* Smallest drift increment. */ 1182 info->z_dx = info->z_dy / info->z_gy; 1183 1184 /* 1185 * Overflow or underflow. Try adaptive, let it continue and 1186 * retry. 1187 */ 1188 if (info->z_dx < 1) { 1189 if (adaptive == 0) { 1190 adaptive = 1; 1191 goto z_setup_adaptive_sinc; 1192 } 1193 return (E2BIG); 1194 } 1195 1196 /* 1197 * Round back output drift. 1198 */ 1199 info->z_dy = info->z_dx * info->z_gy; 1200 1201 for (i = 0; i < Z_COEFF_TAB_SIZE; i++) { 1202 if (Z_SINC_COEFF_IDX(info) != i) 1203 continue; 1204 /* 1205 * Calculate required filter length and guard 1206 * against possible abusive result. Note that 1207 * this represents only 1/2 of the entire filter 1208 * length. 1209 */ 1210 info->z_size = z_resampler_sinc_len(info); 1211 1212 /* 1213 * Multiple of 2 rounding, for better accumulator 1214 * performance. 1215 */ 1216 info->z_size &= ~1; 1217 1218 if (info->z_size < 2 || info->z_size > Z_SINC_MAX) { 1219 if (adaptive == 0) { 1220 adaptive = 1; 1221 goto z_setup_adaptive_sinc; 1222 } 1223 return (E2BIG); 1224 } 1225 info->z_coeff = z_coeff_tab[i].coeff + Z_COEFF_OFFSET; 1226 info->z_dcoeff = z_coeff_tab[i].dcoeff; 1227 break; 1228 } 1229 1230 if (info->z_coeff == NULL || info->z_dcoeff == NULL) 1231 return (EINVAL); 1232 } else if (Z_IS_LINEAR(info)) { 1233 /* 1234 * Don't put much effort if we're doing linear interpolation. 1235 * Just center the interpolation distance within Z_LINEAR_ONE, 1236 * and be happy about it. 1237 */ 1238 info->z_dx = Z_LINEAR_FULL_ONE / info->z_gy; 1239 } 1240 1241 /* 1242 * We're safe for now, lets continue.. Look for our resampler 1243 * depending on configured format and quality. 1244 */ 1245 for (i = 0; i < Z_RESAMPLER_TAB_SIZE; i++) { 1246 int ridx; 1247 1248 if (AFMT_ENCODING(format) != z_resampler_tab[i].format) 1249 continue; 1250 if (Z_IS_SINC(info) && adaptive == 0 && 1251 z_resampler_build_polyphase(info) == 0) 1252 ridx = Z_RESAMPLER_SINC_POLYPHASE; 1253 else 1254 ridx = Z_RESAMPLER_IDX(info); 1255 info->z_resample = z_resampler_tab[i].resampler[ridx]; 1256 break; 1257 } 1258 1259 if (info->z_resample == NULL) 1260 return (EINVAL); 1261 1262 info->bps = AFMT_BPS(format); 1263 align = info->channels * info->bps; 1264 1265 /* 1266 * Calculate largest value that can be fed into z_gy2gx() and 1267 * z_gx2gy() without causing (signed) 32bit overflow. z_gy2gx() will 1268 * be called early during feeding process to determine how much input 1269 * samples that is required to generate requested output, while 1270 * z_gx2gy() will be called just before samples filtering / 1271 * accumulation process based on available samples that has been 1272 * calculated using z_gx2gy(). 1273 * 1274 * Now that is damn confusing, I guess ;-) . 1275 */ 1276 gy2gx_max = (((uint64_t)info->z_gy * INT32_MAX) - info->z_gy + 1) / 1277 info->z_gx; 1278 1279 if ((gy2gx_max * align) > SND_FXDIV_MAX) 1280 gy2gx_max = SND_FXDIV_MAX / align; 1281 1282 if (gy2gx_max < 1) 1283 return (E2BIG); 1284 1285 gx2gy_max = (((uint64_t)info->z_gx * INT32_MAX) - info->z_gy) / 1286 info->z_gy; 1287 1288 if (gx2gy_max > INT32_MAX) 1289 gx2gy_max = INT32_MAX; 1290 1291 if (gx2gy_max < 1) 1292 return (E2BIG); 1293 1294 /* 1295 * Ensure that z_gy2gx() at its largest possible calculated value 1296 * (alpha = 0) will not cause overflow further late during z_gx2gy() 1297 * stage. 1298 */ 1299 if (z_gy2gx(info, gy2gx_max) > _Z_GCAST(gx2gy_max)) 1300 return (E2BIG); 1301 1302 info->z_maxfeed = gy2gx_max * align; 1303 1304#ifdef Z_USE_ALPHADRIFT 1305 info->z_startdrift = z_gy2gx(info, 1); 1306 info->z_alphadrift = z_drift(info, info->z_startdrift, 1); 1307#endif 1308 1309 i = z_gy2gx(info, 1); 1310 info->z_full = z_roundpow2((info->z_size << 1) + i); 1311 1312 /* 1313 * Too big to be true, and overflowing left and right like mad .. 1314 */ 1315 if ((info->z_full * align) < 1) { 1316 if (adaptive == 0 && Z_IS_SINC(info)) { 1317 adaptive = 1; 1318 goto z_setup_adaptive_sinc; 1319 } 1320 return (E2BIG); 1321 } 1322 1323 /* 1324 * Increase full buffer size if its too small to reduce cyclic 1325 * buffer shifting in main conversion/feeder loop. 1326 */ 1327 while (info->z_full < Z_RESERVOIR_MAX && 1328 (info->z_full - (info->z_size << 1)) < Z_RESERVOIR) 1329 info->z_full <<= 1; 1330 1331 /* Initialize buffer position. */ 1332 info->z_mask = info->z_full - 1; 1333 info->z_start = z_prev(info, info->z_size << 1, 1); 1334 info->z_pos = z_next(info, info->z_start, 1); 1335 1336 /* 1337 * Allocate or reuse delay line buffer, whichever makes sense. 1338 */ 1339 i = info->z_full * align; 1340 if (i < 1) 1341 return (E2BIG); 1342 1343 if (info->z_delay == NULL || info->z_alloc < i || 1344 i <= (info->z_alloc >> 1)) { 1345 if (info->z_delay != NULL) 1346 free(info->z_delay, M_DEVBUF); 1347 info->z_delay = malloc(i, M_DEVBUF, M_NOWAIT | M_ZERO); 1348 if (info->z_delay == NULL) 1349 return (ENOMEM); 1350 info->z_alloc = i; 1351 } 1352 1353 /* 1354 * Zero out head of buffer to avoid pops and clicks. 1355 */ 1356 memset(info->z_delay, sndbuf_zerodata(f->desc->out), 1357 info->z_pos * align); 1358 1359#ifdef Z_DIAGNOSTIC 1360 /* 1361 * XXX Debuging mess !@#$%^ 1362 */ 1363#define dumpz(x) fprintf(stderr, "\t%12s = %10u : %-11d\n", \ 1364 "z_"__STRING(x), (uint32_t)info->z_##x, \ 1365 (int32_t)info->z_##x) 1366 fprintf(stderr, "\n%s():\n", __func__); 1367 fprintf(stderr, "\tchannels=%d, bps=%d, format=0x%08x, quality=%d\n", 1368 info->channels, info->bps, format, info->quality); 1369 fprintf(stderr, "\t%d (%d) -> %d (%d), ", 1370 info->src, info->rsrc, info->dst, info->rdst); 1371 fprintf(stderr, "[%d/%d]\n", info->z_gx, info->z_gy); 1372 fprintf(stderr, "\tminreq=%d, ", z_gy2gx(info, 1)); 1373 if (adaptive != 0) 1374 z_scale = Z_ONE; 1375 fprintf(stderr, "factor=0x%08x/0x%08x (%f)\n", 1376 z_scale, Z_ONE, (double)z_scale / Z_ONE); 1377 fprintf(stderr, "\tbase_length=%d, ", Z_SINC_BASE_LEN(info)); 1378 fprintf(stderr, "adaptive=%s\n", (adaptive != 0) ? "YES" : "NO"); 1379 dumpz(size); 1380 dumpz(alloc); 1381 if (info->z_alloc < 1024) 1382 fprintf(stderr, "\t%15s%10d Bytes\n", 1383 "", info->z_alloc); 1384 else if (info->z_alloc < (1024 << 10)) 1385 fprintf(stderr, "\t%15s%10d KBytes\n", 1386 "", info->z_alloc >> 10); 1387 else if (info->z_alloc < (1024 << 20)) 1388 fprintf(stderr, "\t%15s%10d MBytes\n", 1389 "", info->z_alloc >> 20); 1390 else 1391 fprintf(stderr, "\t%15s%10d GBytes\n", 1392 "", info->z_alloc >> 30); 1393 fprintf(stderr, "\t%12s %10d (min output samples)\n", 1394 "", 1395 (int32_t)z_gx2gy(info, info->z_full - (info->z_size << 1))); 1396 fprintf(stderr, "\t%12s %10d (min allocated output samples)\n", 1397 "", 1398 (int32_t)z_gx2gy(info, (info->z_alloc / align) - 1399 (info->z_size << 1))); 1400 fprintf(stderr, "\t%12s = %10d\n", 1401 "z_gy2gx()", (int32_t)z_gy2gx(info, 1)); 1402 fprintf(stderr, "\t%12s = %10d -> z_gy2gx() -> %d\n", 1403 "Max", (int32_t)gy2gx_max, (int32_t)z_gy2gx(info, gy2gx_max)); 1404 fprintf(stderr, "\t%12s = %10d\n", 1405 "z_gx2gy()", (int32_t)z_gx2gy(info, 1)); 1406 fprintf(stderr, "\t%12s = %10d -> z_gx2gy() -> %d\n", 1407 "Max", (int32_t)gx2gy_max, (int32_t)z_gx2gy(info, gx2gy_max)); 1408 dumpz(maxfeed); 1409 dumpz(full); 1410 dumpz(start); 1411 dumpz(pos); 1412 dumpz(scale); 1413 fprintf(stderr, "\t%12s %10f\n", "", 1414 (double)info->z_scale / Z_ONE); 1415 dumpz(dx); 1416 fprintf(stderr, "\t%12s %10f\n", "", 1417 (double)info->z_dx / info->z_dy); 1418 dumpz(dy); 1419 fprintf(stderr, "\t%12s %10d (drift step)\n", "", 1420 info->z_dy >> Z_SHIFT); 1421 fprintf(stderr, "\t%12s %10d (scaling differences)\n", "", 1422 (z_scale << Z_DRIFT_SHIFT) - info->z_dy); 1423 fprintf(stderr, "\t%12s = %u bytes\n", 1424 "intpcm32_t", sizeof(intpcm32_t)); 1425 fprintf(stderr, "\t%12s = 0x%08x, smallest=%.16lf\n", 1426 "Z_ONE", Z_ONE, (double)1.0 / (double)Z_ONE); 1427#endif 1428 1429 return (0); 1430} 1431 1432static int 1433z_resampler_set(struct pcm_feeder *f, int what, int32_t value) 1434{ 1435 struct z_info *info; 1436 int32_t oquality; 1437 1438 info = f->data; 1439 1440 switch (what) { 1441 case Z_RATE_SRC: 1442 if (value < feeder_rate_min || value > feeder_rate_max) 1443 return (E2BIG); 1444 if (value == info->rsrc) 1445 return (0); 1446 info->rsrc = value; 1447 break; 1448 case Z_RATE_DST: 1449 if (value < feeder_rate_min || value > feeder_rate_max) 1450 return (E2BIG); 1451 if (value == info->rdst) 1452 return (0); 1453 info->rdst = value; 1454 break; 1455 case Z_RATE_QUALITY: 1456 if (value < Z_QUALITY_MIN || value > Z_QUALITY_MAX) 1457 return (EINVAL); 1458 if (value == info->quality) 1459 return (0); 1460 /* 1461 * If we failed to set the requested quality, restore 1462 * the old one. We cannot afford leaving it broken since 1463 * passive feeder chains like vchans never reinitialize 1464 * itself. 1465 */ 1466 oquality = info->quality; 1467 info->quality = value; 1468 if (z_resampler_setup(f) == 0) 1469 return (0); 1470 info->quality = oquality; 1471 break; 1472 case Z_RATE_CHANNELS: 1473 if (value < SND_CHN_MIN || value > SND_CHN_MAX) 1474 return (EINVAL); 1475 if (value == info->channels) 1476 return (0); 1477 info->channels = value; 1478 break; 1479 default: 1480 return (EINVAL); 1481 break; 1482 } 1483 1484 return (z_resampler_setup(f)); 1485} 1486 1487static int 1488z_resampler_get(struct pcm_feeder *f, int what) 1489{ 1490 struct z_info *info; 1491 1492 info = f->data; 1493 1494 switch (what) { 1495 case Z_RATE_SRC: 1496 return (info->rsrc); 1497 break; 1498 case Z_RATE_DST: 1499 return (info->rdst); 1500 break; 1501 case Z_RATE_QUALITY: 1502 return (info->quality); 1503 break; 1504 case Z_RATE_CHANNELS: 1505 return (info->channels); 1506 break; 1507 default: 1508 break; 1509 } 1510 1511 return (-1); 1512} 1513 1514static int 1515z_resampler_init(struct pcm_feeder *f) 1516{ 1517 struct z_info *info; 1518 int ret; 1519 1520 if (f->desc->in != f->desc->out) 1521 return (EINVAL); 1522 1523 info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO); 1524 if (info == NULL) 1525 return (ENOMEM); 1526 1527 info->rsrc = Z_RATE_DEFAULT; 1528 info->rdst = Z_RATE_DEFAULT; 1529 info->quality = feeder_rate_quality; 1530 info->channels = AFMT_CHANNEL(f->desc->in); 1531 1532 f->data = info; 1533 1534 ret = z_resampler_setup(f); 1535 if (ret != 0) { 1536 if (info->z_pcoeff != NULL) 1537 free(info->z_pcoeff, M_DEVBUF); 1538 if (info->z_delay != NULL) 1539 free(info->z_delay, M_DEVBUF); 1540 free(info, M_DEVBUF); 1541 f->data = NULL; 1542 } 1543 1544 return (ret); 1545} 1546 1547static int 1548z_resampler_free(struct pcm_feeder *f) 1549{ 1550 struct z_info *info; 1551 1552 info = f->data; 1553 if (info != NULL) { 1554 if (info->z_pcoeff != NULL) 1555 free(info->z_pcoeff, M_DEVBUF); 1556 if (info->z_delay != NULL) 1557 free(info->z_delay, M_DEVBUF); 1558 free(info, M_DEVBUF); 1559 } 1560 1561 f->data = NULL; 1562 1563 return (0); 1564} 1565 1566static uint32_t 1567z_resampler_feed_internal(struct pcm_feeder *f, struct pcm_channel *c, 1568 uint8_t *b, uint32_t count, void *source) 1569{ 1570 struct z_info *info; 1571 int32_t alphadrift, startdrift, reqout, ocount, reqin, align; 1572 int32_t fetch, fetched, start, cp; 1573 uint8_t *dst; 1574 1575 info = f->data; 1576 if (info->z_resample == NULL) 1577 return (z_feed(f->source, c, b, count, source)); 1578 1579 /* 1580 * Calculate sample size alignment and amount of sample output. 1581 * We will do everything in sample domain, but at the end we 1582 * will jump back to byte domain. 1583 */ 1584 align = info->channels * info->bps; 1585 ocount = SND_FXDIV(count, align); 1586 if (ocount == 0) 1587 return (0); 1588 1589 /* 1590 * Calculate amount of input samples that is needed to generate 1591 * exact amount of output. 1592 */ 1593 reqin = z_gy2gx(info, ocount) - z_fetched(info); 1594 1595#ifdef Z_USE_ALPHADRIFT 1596 startdrift = info->z_startdrift; 1597 alphadrift = info->z_alphadrift; 1598#else 1599 startdrift = _Z_GY2GX(info, 0, 1); 1600 alphadrift = z_drift(info, startdrift, 1); 1601#endif 1602 1603 dst = b; 1604 1605 do { 1606 if (reqin != 0) { 1607 fetch = z_min(z_free(info), reqin); 1608 if (fetch == 0) { 1609 /* 1610 * No more free spaces, so wind enough 1611 * samples back to the head of delay line 1612 * in byte domain. 1613 */ 1614 fetched = z_fetched(info); 1615 start = z_prev(info, info->z_start, 1616 (info->z_size << 1) - 1); 1617 cp = (info->z_size << 1) + fetched; 1618 z_copy(info->z_delay + (start * align), 1619 info->z_delay, cp * align); 1620 info->z_start = 1621 z_prev(info, info->z_size << 1, 1); 1622 info->z_pos = 1623 z_next(info, info->z_start, fetched + 1); 1624 fetch = z_min(z_free(info), reqin); 1625#ifdef Z_DIAGNOSTIC 1626 if (1) { 1627 static uint32_t kk = 0; 1628 fprintf(stderr, 1629 "Buffer Move: " 1630 "start=%d fetched=%d cp=%d " 1631 "cycle=%u [%u]\r", 1632 start, fetched, cp, info->z_cycle, 1633 ++kk); 1634 } 1635 info->z_cycle = 0; 1636#endif 1637 } 1638 if (fetch != 0) { 1639 /* 1640 * Fetch in byte domain and jump back 1641 * to sample domain. 1642 */ 1643 fetched = SND_FXDIV(z_feed(f->source, c, 1644 info->z_delay + (info->z_pos * align), 1645 fetch * align, source), align); 1646 /* 1647 * Prepare to convert fetched buffer, 1648 * or mark us done if we cannot fulfill 1649 * the request. 1650 */ 1651 reqin -= fetched; 1652 info->z_pos += fetched; 1653 if (fetched != fetch) 1654 reqin = 0; 1655 } 1656 } 1657 1658 reqout = z_min(z_gx2gy(info, z_fetched(info)), ocount); 1659 if (reqout != 0) { 1660 ocount -= reqout; 1661 1662 /* 1663 * Drift.. drift.. drift.. 1664 * 1665 * Notice that there are 2 methods of doing the drift 1666 * operations: The former is much cleaner (in a sense 1667 * of mathematical readings of my eyes), but slower 1668 * due to integer division in z_gy2gx(). Nevertheless, 1669 * both should give the same exact accurate drifting 1670 * results, so the later is favourable. 1671 */ 1672 do { 1673 info->z_resample(info, dst); 1674#if 0 1675 startdrift = z_gy2gx(info, 1); 1676 alphadrift = z_drift(info, startdrift, 1); 1677 info->z_start += startdrift; 1678 info->z_alpha += alphadrift; 1679#else 1680 info->z_alpha += alphadrift; 1681 if (info->z_alpha < info->z_gy) 1682 info->z_start += startdrift; 1683 else { 1684 info->z_start += startdrift - 1; 1685 info->z_alpha -= info->z_gy; 1686 } 1687#endif 1688 dst += align; 1689#ifdef Z_DIAGNOSTIC 1690 info->z_cycle++; 1691#endif 1692 } while (--reqout != 0); 1693 } 1694 } while (reqin != 0 && ocount != 0); 1695 1696 /* 1697 * Back to byte domain.. 1698 */ 1699 return (dst - b); 1700} 1701 1702static int 1703z_resampler_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b, 1704 uint32_t count, void *source) 1705{ 1706 uint32_t feed, maxfeed, left; 1707 1708 /* 1709 * Split count to smaller chunks to avoid possible 32bit overflow. 1710 */ 1711 maxfeed = ((struct z_info *)(f->data))->z_maxfeed; 1712 left = count; 1713 1714 do { 1715 feed = z_resampler_feed_internal(f, c, b, 1716 z_min(maxfeed, left), source); 1717 b += feed; 1718 left -= feed; 1719 } while (left != 0 && feed != 0); 1720 1721 return (count - left); 1722} 1723 1724static struct pcm_feederdesc feeder_rate_desc[] = { 1725 { FEEDER_RATE, 0, 0, 0, 0 }, 1726 { 0, 0, 0, 0, 0 }, 1727}; 1728 1729static kobj_method_t feeder_rate_methods[] = { 1730 KOBJMETHOD(feeder_init, z_resampler_init), 1731 KOBJMETHOD(feeder_free, z_resampler_free), 1732 KOBJMETHOD(feeder_set, z_resampler_set), 1733 KOBJMETHOD(feeder_get, z_resampler_get), 1734 KOBJMETHOD(feeder_feed, z_resampler_feed), 1735 KOBJMETHOD_END 1736}; 1737 1738FEEDER_DECLARE(feeder_rate, NULL); 1739