feeder_rate.c revision 167646
1/*- 2 * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org> 3 * Copyright (c) 2003 Orion Hodson <orion@FreeBSD.org> 4 * Copyright (c) 2005 Ariff Abdullah <ariff@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * 2006-02-21: 29 * ========== 30 * 31 * Major cleanup and overhaul to remove much redundant codes. 32 * Highlights: 33 * 1) Support for signed / unsigned 16, 24 and 32 bit, 34 * big / little endian, 35 * 2) Unlimited channels. 36 * 37 * 2005-06-11: 38 * ========== 39 * 40 * *New* and rewritten soft sample rate converter supporting arbitrary sample 41 * rates, fine grained scaling/coefficients and a unified up/down stereo 42 * converter. Most of the disclaimers from orion's notes also applies 43 * here, regarding linear interpolation deficiencies and pre/post 44 * anti-aliasing filtering issues. This version comes with a much simpler and 45 * tighter interface, although it works almost exactly like the older one. 46 * 47 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 48 * * 49 * This new implementation is fully dedicated in memory of Cameron Grant, * 50 * the creator of the magnificent, highly addictive feeder infrastructure. * 51 * * 52 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 53 * 54 * Orion's notes: 55 * ============= 56 * 57 * This rate conversion code uses linear interpolation without any 58 * pre- or post- interpolation filtering to combat aliasing. This 59 * greatly limits the sound quality and should be addressed at some 60 * stage in the future. 61 * 62 * Since this accuracy of interpolation is sensitive and examination 63 * of the algorithm output is harder from the kernel, the code is 64 * designed to be compiled in the kernel and in a userland test 65 * harness. This is done by selectively including and excluding code 66 * with several portions based on whether _KERNEL is defined. It's a 67 * little ugly, but exceedingly useful. The testsuite and its 68 * revisions can be found at: 69 * http://people.freebsd.org/~orion/files/feedrate/ 70 * 71 * Special thanks to Ken Marx for exposing flaws in the code and for 72 * testing revisions. 73 */ 74 75#include <dev/sound/pcm/sound.h> 76#include "feeder_if.h" 77 78SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/pcm/feeder_rate.c 167646 2007-03-16 17:16:56Z ariff $"); 79 80#define RATE_ASSERT(x, y) /* KASSERT(x,y) */ 81#define RATE_TEST(x, y) /* if (!(x)) printf y */ 82#define RATE_TRACE(x...) /* printf(x) */ 83 84MALLOC_DEFINE(M_RATEFEEDER, "ratefeed", "pcm rate feeder"); 85 86/* 87 * Don't overflow 32bit integer, since everything is done 88 * within 32bit arithmetic. 89 */ 90#define RATE_FACTOR_MIN 1 91#define RATE_FACTOR_MAX PCM_S24_MAX 92#define RATE_FACTOR_SAFE(val) (!((val) < RATE_FACTOR_MIN || \ 93 (val) > RATE_FACTOR_MAX)) 94 95struct feed_rate_info; 96 97typedef uint32_t (*feed_rate_converter)(struct feed_rate_info *, 98 uint8_t *, uint32_t); 99 100struct feed_rate_info { 101 uint32_t src, dst; /* rounded source / destination rates */ 102 uint32_t rsrc, rdst; /* original source / destination rates */ 103 uint32_t gx, gy; /* interpolation / decimation ratio */ 104 uint32_t alpha; /* interpolation distance */ 105 uint32_t pos, bpos; /* current sample / buffer positions */ 106 uint32_t bufsz; /* total buffer size limit */ 107 uint32_t bufsz_init; /* allocated buffer size */ 108 uint32_t channels; /* total channels */ 109 uint32_t bps; /* bytes-per-sample */ 110#ifdef FEEDRATE_STRAY 111 uint32_t stray; /* stray bytes */ 112#endif 113 uint8_t *buffer; 114 feed_rate_converter convert; 115}; 116 117int feeder_rate_min = FEEDRATE_RATEMIN; 118int feeder_rate_max = FEEDRATE_RATEMAX; 119int feeder_rate_round = FEEDRATE_ROUNDHZ; 120 121TUNABLE_INT("hw.snd.feeder_rate_min", &feeder_rate_min); 122TUNABLE_INT("hw.snd.feeder_rate_max", &feeder_rate_max); 123TUNABLE_INT("hw.snd.feeder_rate_round", &feeder_rate_round); 124 125static int 126sysctl_hw_snd_feeder_rate_min(SYSCTL_HANDLER_ARGS) 127{ 128 int err, val; 129 130 val = feeder_rate_min; 131 err = sysctl_handle_int(oidp, &val, sizeof(val), req); 132 if (err != 0 || req->newptr == NULL) 133 return (err); 134 if (RATE_FACTOR_SAFE(val) && val < feeder_rate_max) 135 feeder_rate_min = val; 136 else 137 err = EINVAL; 138 return (err); 139} 140SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_min, CTLTYPE_INT | CTLFLAG_RW, 141 0, sizeof(int), sysctl_hw_snd_feeder_rate_min, "I", 142 "minimum allowable rate"); 143 144static int 145sysctl_hw_snd_feeder_rate_max(SYSCTL_HANDLER_ARGS) 146{ 147 int err, val; 148 149 val = feeder_rate_max; 150 err = sysctl_handle_int(oidp, &val, sizeof(val), req); 151 if (err != 0 || req->newptr == NULL) 152 return (err); 153 if (RATE_FACTOR_SAFE(val) && val > feeder_rate_min) 154 feeder_rate_max = val; 155 else 156 err = EINVAL; 157 return (err); 158} 159SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_max, CTLTYPE_INT | CTLFLAG_RW, 160 0, sizeof(int), sysctl_hw_snd_feeder_rate_max, "I", 161 "maximum allowable rate"); 162 163static int 164sysctl_hw_snd_feeder_rate_round(SYSCTL_HANDLER_ARGS) 165{ 166 int err, val; 167 168 val = feeder_rate_round; 169 err = sysctl_handle_int(oidp, &val, sizeof(val), req); 170 if (err != 0 || req->newptr == NULL) 171 return (err); 172 if (val < FEEDRATE_ROUNDHZ_MIN || val > FEEDRATE_ROUNDHZ_MAX) 173 err = EINVAL; 174 else 175 feeder_rate_round = val - (val % FEEDRATE_ROUNDHZ); 176 return (err); 177} 178SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_round, CTLTYPE_INT | CTLFLAG_RW, 179 0, sizeof(int), sysctl_hw_snd_feeder_rate_round, "I", 180 "sample rate converter rounding threshold"); 181 182#define FEEDER_RATE_CONVERT(FMTBIT, RATE_INTCAST, SIGN, SIGNS, ENDIAN, ENDIANS) \ 183static uint32_t \ 184feed_convert_##SIGNS##FMTBIT##ENDIANS(struct feed_rate_info *info, \ 185 uint8_t *dst, uint32_t max) \ 186{ \ 187 uint32_t ret, smpsz, ch, pos, bpos, gx, gy, alpha, d1, d2; \ 188 int32_t x, y; \ 189 int i; \ 190 uint8_t *src, *sx, *sy; \ 191 \ 192 ret = 0; \ 193 alpha = info->alpha; \ 194 gx = info->gx; \ 195 gy = info->gy; \ 196 pos = info->pos; \ 197 bpos = info->bpos; \ 198 src = info->buffer + pos; \ 199 ch = info->channels; \ 200 smpsz = PCM_##FMTBIT##_BPS * ch; \ 201 for (;;) { \ 202 if (alpha < gx) { \ 203 alpha += gy; \ 204 pos += smpsz; \ 205 if (pos == bpos) \ 206 break; \ 207 src += smpsz; \ 208 } else { \ 209 alpha -= gx; \ 210 d1 = (alpha << PCM_FXSHIFT) / gy; \ 211 d2 = (1U << PCM_FXSHIFT) - d1; \ 212 sx = src - smpsz; \ 213 sy = src; \ 214 i = ch; \ 215 do { \ 216 x = PCM_READ_##SIGN##FMTBIT##_##ENDIAN(sx); \ 217 y = PCM_READ_##SIGN##FMTBIT##_##ENDIAN(sy); \ 218 x = (((RATE_INTCAST)x * d1) + \ 219 ((RATE_INTCAST)y * d2)) >> PCM_FXSHIFT; \ 220 PCM_WRITE_##SIGN##FMTBIT##_##ENDIAN(dst, x); \ 221 dst += PCM_##FMTBIT##_BPS; \ 222 sx += PCM_##FMTBIT##_BPS; \ 223 sy += PCM_##FMTBIT##_BPS; \ 224 ret += PCM_##FMTBIT##_BPS; \ 225 } while (--i != 0); \ 226 if (ret == max) \ 227 break; \ 228 } \ 229 } \ 230 info->alpha = alpha; \ 231 info->pos = pos; \ 232 return (ret); \ 233} 234 235FEEDER_RATE_CONVERT(8, int32_t, S, s, NE, ne) 236FEEDER_RATE_CONVERT(16, int32_t, S, s, LE, le) 237FEEDER_RATE_CONVERT(24, int32_t, S, s, LE, le) 238FEEDER_RATE_CONVERT(32, intpcm_t, S, s, LE, le) 239FEEDER_RATE_CONVERT(16, int32_t, S, s, BE, be) 240FEEDER_RATE_CONVERT(24, int32_t, S, s, BE, be) 241FEEDER_RATE_CONVERT(32, intpcm_t, S, s, BE, be) 242FEEDER_RATE_CONVERT(8, int32_t, U, u, NE, ne) 243FEEDER_RATE_CONVERT(16, int32_t, U, u, LE, le) 244FEEDER_RATE_CONVERT(24, int32_t, U, u, LE, le) 245FEEDER_RATE_CONVERT(32, intpcm_t, U, u, LE, le) 246FEEDER_RATE_CONVERT(16, int32_t, U, u, BE, be) 247FEEDER_RATE_CONVERT(24, int32_t, U, u, BE, be) 248FEEDER_RATE_CONVERT(32, intpcm_t, U, u, BE, be) 249 250static void 251feed_speed_ratio(uint32_t src, uint32_t dst, uint32_t *gx, uint32_t *gy) 252{ 253 uint32_t w, x = src, y = dst; 254 255 while (y != 0) { 256 w = x % y; 257 x = y; 258 y = w; 259 } 260 *gx = src / x; 261 *gy = dst / x; 262} 263 264static void 265feed_rate_reset(struct feed_rate_info *info) 266{ 267 info->src = info->rsrc - (info->rsrc % 268 ((feeder_rate_round > 0) ? feeder_rate_round : 1)); 269 info->dst = info->rdst - (info->rdst % 270 ((feeder_rate_round > 0) ? feeder_rate_round : 1)); 271 info->gx = 1; 272 info->gy = 1; 273 info->alpha = 0; 274 info->channels = 1; 275 info->bps = PCM_8_BPS; 276 info->convert = NULL; 277 info->bufsz = info->bufsz_init; 278 info->pos = 1; 279 info->bpos = 2; 280#ifdef FEEDRATE_STRAY 281 info->stray = 0; 282#endif 283} 284 285static int 286feed_rate_setup(struct pcm_feeder *f) 287{ 288 struct feed_rate_info *info = f->data; 289 static const struct { 290 uint32_t format; /* pcm / audio format */ 291 uint32_t bps; /* bytes-per-sample, regardless of 292 total channels */ 293 feed_rate_converter convert; 294 } convtbl[] = { 295 { AFMT_S8, PCM_8_BPS, feed_convert_s8ne }, 296 { AFMT_S16_LE, PCM_16_BPS, feed_convert_s16le }, 297 { AFMT_S24_LE, PCM_24_BPS, feed_convert_s24le }, 298 { AFMT_S32_LE, PCM_32_BPS, feed_convert_s32le }, 299 { AFMT_S16_BE, PCM_16_BPS, feed_convert_s16be }, 300 { AFMT_S24_BE, PCM_24_BPS, feed_convert_s24be }, 301 { AFMT_S32_BE, PCM_32_BPS, feed_convert_s32be }, 302 { AFMT_U8, PCM_8_BPS, feed_convert_u8ne }, 303 { AFMT_U16_LE, PCM_16_BPS, feed_convert_u16le }, 304 { AFMT_U24_LE, PCM_24_BPS, feed_convert_u24le }, 305 { AFMT_U32_LE, PCM_32_BPS, feed_convert_u32le }, 306 { AFMT_U16_BE, PCM_16_BPS, feed_convert_u16be }, 307 { AFMT_U24_BE, PCM_24_BPS, feed_convert_u24be }, 308 { AFMT_U32_BE, PCM_32_BPS, feed_convert_u32be }, 309 { 0, 0, NULL }, 310 }; 311 uint32_t i; 312 313 feed_rate_reset(info); 314 315 if (info->src != info->dst) 316 feed_speed_ratio(info->src, info->dst, &info->gx, &info->gy); 317 318 if (!(RATE_FACTOR_SAFE(info->gx) && RATE_FACTOR_SAFE(info->gy))) 319 return (-1); 320 321 for (i = 0; i < sizeof(convtbl) / sizeof(*convtbl); i++) { 322 if (convtbl[i].format == 0) 323 return (-1); 324 if ((f->desc->out & ~AFMT_STEREO) == convtbl[i].format) { 325 info->bps = convtbl[i].bps; 326 info->convert = convtbl[i].convert; 327 break; 328 } 329 } 330 331 /* 332 * No need to interpolate/decimate, just do plain copy. 333 */ 334 if (info->gx == info->gy) 335 info->convert = NULL; 336 337 info->channels = (f->desc->out & AFMT_STEREO) ? 2 : 1; 338 info->pos = info->bps * info->channels; 339 info->bpos = info->pos << 1; 340 info->bufsz -= info->bufsz % info->pos; 341 342 memset(info->buffer, sndbuf_zerodata(f->desc->out), info->bpos); 343 344 RATE_TRACE("%s: %u (%u) -> %u (%u) [%u/%u] , " 345 "format=0x%08x, channels=%u, bufsz=%u\n", 346 __func__, info->src, info->rsrc, info->dst, info->rdst, 347 info->gx, info->gy, f->desc->out, info->channels, 348 info->bufsz - info->pos); 349 350 return (0); 351} 352 353static int 354feed_rate_set(struct pcm_feeder *f, int what, int32_t value) 355{ 356 struct feed_rate_info *info = f->data; 357 358 if (value < feeder_rate_min || value > feeder_rate_max) 359 return (-1); 360 361 switch (what) { 362 case FEEDRATE_SRC: 363 info->rsrc = value; 364 break; 365 case FEEDRATE_DST: 366 info->rdst = value; 367 break; 368 default: 369 return (-1); 370 } 371 return (feed_rate_setup(f)); 372} 373 374static int 375feed_rate_get(struct pcm_feeder *f, int what) 376{ 377 struct feed_rate_info *info = f->data; 378 379 switch (what) { 380 case FEEDRATE_SRC: 381 return (info->rsrc); 382 case FEEDRATE_DST: 383 return (info->rdst); 384 default: 385 return (-1); 386 } 387 return (-1); 388} 389 390static int 391feed_rate_init(struct pcm_feeder *f) 392{ 393 struct feed_rate_info *info; 394 395 if (f->desc->out != f->desc->in) 396 return (EINVAL); 397 398 info = malloc(sizeof(*info), M_RATEFEEDER, M_NOWAIT | M_ZERO); 399 if (info == NULL) 400 return (ENOMEM); 401 /* 402 * bufsz = sample from last cycle + conversion space 403 */ 404 info->bufsz_init = 8 + feeder_buffersize; 405 info->buffer = malloc(sizeof(*info->buffer) * info->bufsz_init, 406 M_RATEFEEDER, M_NOWAIT | M_ZERO); 407 if (info->buffer == NULL) { 408 free(info, M_RATEFEEDER); 409 return (ENOMEM); 410 } 411 info->rsrc = DSP_DEFAULT_SPEED; 412 info->rdst = DSP_DEFAULT_SPEED; 413 f->data = info; 414 return (feed_rate_setup(f)); 415} 416 417static int 418feed_rate_free(struct pcm_feeder *f) 419{ 420 struct feed_rate_info *info = f->data; 421 422 if (info != NULL) { 423 if (info->buffer != NULL) 424 free(info->buffer, M_RATEFEEDER); 425 free(info, M_RATEFEEDER); 426 } 427 f->data = NULL; 428 return (0); 429} 430 431static int 432feed_rate(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b, 433 uint32_t count, void *source) 434{ 435 struct feed_rate_info *info = f->data; 436 uint32_t i, smpsz; 437 int32_t fetch, slot; 438 439 if (info->convert == NULL) 440 return (FEEDER_FEED(f->source, c, b, count, source)); 441 442 /* 443 * This loop has been optimized to generalize both up / down 444 * sampling without causing missing samples or excessive buffer 445 * feeding. The tricky part is to calculate *precise* (slot) value 446 * needed for the entire conversion space since we are bound to 447 * return and fill up the buffer according to the requested 'count'. 448 * Too much feeding will cause the extra buffer stay within temporary 449 * circular buffer forever and always manifest itself as a truncated 450 * sound during end of playback / recording. Too few, and we end up 451 * with possible underruns and waste of cpu cycles. 452 * 453 * 'Stray' management exist to combat with possible unaligned 454 * buffering by the caller. 455 */ 456 smpsz = info->bps * info->channels; 457 RATE_TEST(count >= smpsz && (count % smpsz) == 0, 458 ("%s: Count size not sample integral (%d)\n", __func__, count)); 459 if (count < smpsz) 460 return (0); 461 count -= count % smpsz; 462 /* 463 * This slot count formula will stay here for the next million years 464 * to come. This is the key of our circular buffering precision. 465 */ 466 slot = (((info->gx * (count / smpsz)) + info->gy - info->alpha - 1) / 467 info->gy) * smpsz; 468 RATE_TEST((slot % smpsz) == 0, 469 ("%s: Slot count not sample integral (%d)\n", __func__, slot)); 470#ifdef FEEDRATE_STRAY 471 RATE_TEST(info->stray == 0, ("%s: [1] Stray bytes: %u\n", __func__, 472 info->stray)); 473#endif 474 if (info->pos != smpsz && info->bpos - info->pos == smpsz && 475 info->bpos + slot > info->bufsz) { 476 /* 477 * Copy last unit sample and its previous to 478 * beginning of buffer. 479 */ 480 bcopy(info->buffer + info->pos - smpsz, info->buffer, 481 sizeof(*info->buffer) * (smpsz << 1)); 482 info->pos = smpsz; 483 info->bpos = smpsz << 1; 484 } 485 RATE_ASSERT(slot >= 0, ("%s: Negative Slot: %d\n", __func__, slot)); 486 i = 0; 487 for (;;) { 488 for (;;) { 489 fetch = info->bufsz - info->bpos; 490#ifdef FEEDRATE_STRAY 491 fetch -= info->stray; 492#endif 493 RATE_ASSERT(fetch >= 0, 494 ("%s: [1] Buffer overrun: %d > %d\n", __func__, 495 info->bpos, info->bufsz)); 496 if (slot < fetch) 497 fetch = slot; 498#ifdef FEEDRATE_STRAY 499 if (fetch < 1) 500#else 501 if (fetch < smpsz) 502#endif 503 break; 504 RATE_ASSERT((int)(info->bpos 505#ifdef FEEDRATE_STRAY 506 - info->stray 507#endif 508 ) >= 0 && 509 (info->bpos - info->stray) < info->bufsz, 510 ("%s: DANGER - BUFFER OVERRUN! bufsz=%d, pos=%d\n", 511 __func__, info->bufsz, info->bpos 512#ifdef FEEDRATE_STRAY 513 - info->stray 514#endif 515 )); 516 fetch = FEEDER_FEED(f->source, c, 517 info->buffer + info->bpos 518#ifdef FEEDRATE_STRAY 519 - info->stray 520#endif 521 , fetch, source); 522#ifdef FEEDRATE_STRAY 523 info->stray = 0; 524 if (fetch == 0) 525#else 526 if (fetch < smpsz) 527#endif 528 break; 529 RATE_TEST((fetch % smpsz) == 0, 530 ("%s: Fetch size not sample integral (%d)\n", 531 __func__, fetch)); 532#ifdef FEEDRATE_STRAY 533 info->stray += fetch % smpsz; 534 RATE_TEST(info->stray == 0, 535 ("%s: Stray bytes detected (%d)\n", __func__, 536 info->stray)); 537#endif 538 fetch -= fetch % smpsz; 539 info->bpos += fetch; 540 slot -= fetch; 541 RATE_ASSERT(slot >= 0, ("%s: Negative Slot: %d\n", 542 __func__, slot)); 543 if (slot == 0 || info->bpos == info->bufsz) 544 break; 545 } 546 if (info->pos == info->bpos) { 547 RATE_TEST(info->pos == smpsz, 548 ("%s: EOF while in progress\n", __func__)); 549 break; 550 } 551 RATE_ASSERT(info->pos <= info->bpos, 552 ("%s: [2] Buffer overrun: %d > %d\n", __func__, info->pos, 553 info->bpos)); 554 RATE_ASSERT(info->pos < info->bpos, 555 ("%s: Zero buffer!\n", __func__)); 556 RATE_ASSERT(((info->bpos - info->pos) % smpsz) == 0, 557 ("%s: Buffer not sample integral (%d)\n", __func__, 558 info->bpos - info->pos)); 559 i += info->convert(info, b + i, count - i); 560 RATE_ASSERT(info->pos <= info->bpos, 561 ("%s: [3] Buffer overrun: %d > %d\n", __func__, info->pos, 562 info->bpos)); 563 if (info->pos == info->bpos) { 564 /* 565 * End of buffer cycle. Copy last unit sample 566 * to beginning of buffer so next cycle can 567 * interpolate using it. 568 */ 569#ifdef FEEDRATE_STRAY 570 RATE_TEST(info->stray == 0, 571 ("%s: [2] Stray bytes: %u\n", __func__, 572 info->stray)); 573#endif 574 bcopy(info->buffer + info->pos - smpsz, info->buffer, 575 sizeof(*info->buffer) * smpsz); 576 info->bpos = smpsz; 577 info->pos = smpsz; 578 } 579 if (i == count) 580 break; 581 } 582 583 RATE_TEST((slot == 0 && count == i) || (slot > 0 && count > i && 584 info->pos == info->bpos && info->pos == smpsz), 585 ("%s: Inconsistent slot/count! " 586 "Count Expect: %u , Got: %u, Slot Left: %d\n", __func__, count, i, 587 slot)); 588 589#ifdef FEEDRATE_STRAY 590 RATE_TEST(info->stray == 0, ("%s: [3] Stray bytes: %u\n", __func__, 591 info->stray)); 592#endif 593 594 return (i); 595} 596 597static struct pcm_feederdesc feeder_rate_desc[] = { 598 {FEEDER_RATE, AFMT_S8, AFMT_S8, 0}, 599 {FEEDER_RATE, AFMT_S16_LE, AFMT_S16_LE, 0}, 600 {FEEDER_RATE, AFMT_S24_LE, AFMT_S24_LE, 0}, 601 {FEEDER_RATE, AFMT_S32_LE, AFMT_S32_LE, 0}, 602 {FEEDER_RATE, AFMT_S16_BE, AFMT_S16_BE, 0}, 603 {FEEDER_RATE, AFMT_S24_BE, AFMT_S24_BE, 0}, 604 {FEEDER_RATE, AFMT_S32_BE, AFMT_S32_BE, 0}, 605 {FEEDER_RATE, AFMT_S8 | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0}, 606 {FEEDER_RATE, AFMT_S16_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0}, 607 {FEEDER_RATE, AFMT_S24_LE | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0}, 608 {FEEDER_RATE, AFMT_S32_LE | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0}, 609 {FEEDER_RATE, AFMT_S16_BE | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0}, 610 {FEEDER_RATE, AFMT_S24_BE | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0}, 611 {FEEDER_RATE, AFMT_S32_BE | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0}, 612 {FEEDER_RATE, AFMT_U8, AFMT_U8, 0}, 613 {FEEDER_RATE, AFMT_U16_LE, AFMT_U16_LE, 0}, 614 {FEEDER_RATE, AFMT_U24_LE, AFMT_U24_LE, 0}, 615 {FEEDER_RATE, AFMT_U32_LE, AFMT_U32_LE, 0}, 616 {FEEDER_RATE, AFMT_U16_BE, AFMT_U16_BE, 0}, 617 {FEEDER_RATE, AFMT_U24_BE, AFMT_U24_BE, 0}, 618 {FEEDER_RATE, AFMT_U32_BE, AFMT_U32_BE, 0}, 619 {FEEDER_RATE, AFMT_U8 | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0}, 620 {FEEDER_RATE, AFMT_U16_LE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0}, 621 {FEEDER_RATE, AFMT_U24_LE | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0}, 622 {FEEDER_RATE, AFMT_U32_LE | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0}, 623 {FEEDER_RATE, AFMT_U16_BE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0}, 624 {FEEDER_RATE, AFMT_U24_BE | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0}, 625 {FEEDER_RATE, AFMT_U32_BE | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0}, 626 {0, 0, 0, 0}, 627}; 628 629static kobj_method_t feeder_rate_methods[] = { 630 KOBJMETHOD(feeder_init, feed_rate_init), 631 KOBJMETHOD(feeder_free, feed_rate_free), 632 KOBJMETHOD(feeder_set, feed_rate_set), 633 KOBJMETHOD(feeder_get, feed_rate_get), 634 KOBJMETHOD(feeder_feed, feed_rate), 635 {0, 0} 636}; 637 638FEEDER_DECLARE(feeder_rate, 2, NULL); 639