sys/dev/sound/pcm/buffer.c

   1 /*-
   2  * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org>
   3  * Portions Copyright (c) Ryan Beasley <ryan.beasley@gmail.com> - GSoC 2006
   4  * Copyright (c) 1999 Cameron Grant <cg@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
  29 #ifdef HAVE_KERNEL_OPTION_HEADERS
  30 #include "opt_snd.h"
  31 #endif
  32
  33 #include <dev/sound/pcm/sound.h>
  34
  35 #include "feeder_if.h"
  36
  37 #define SND_USE_FXDIV
  38 #include "snd_fxdiv_gen.h"
  39
  40 SND_DECLARE_FILE("$FreeBSD$");
  41
  42 struct snd_dbuf *
  43 sndbuf_create(device_t dev, char *drv, char *desc, struct pcm_channel *channel)
  44 {
  45         struct snd_dbuf *b;
  46
  47         b = malloc(sizeof(*b), M_DEVBUF, M_WAITOK | M_ZERO);
  48         snprintf(b->name, SNDBUF_NAMELEN, "%s:%s", drv, desc);
  49         b->dev = dev;
  50         b->channel = channel;
  51
  52         return b;
  53 }
  54
  55 void
  56 sndbuf_destroy(struct snd_dbuf *b)
  57 {
  58         sndbuf_free(b);
  59         free(b, M_DEVBUF);
  60 }
  61
  62 bus_addr_t
  63 sndbuf_getbufaddr(struct snd_dbuf *buf)
  64 {
  65         return (buf->buf_addr);
  66 }
  67
  68 static void
  69 sndbuf_setmap(void *arg, bus_dma_segment_t *segs, int nseg, int error)
  70 {
  71         struct snd_dbuf *b = (struct snd_dbuf *)arg;
  72
  73         if (bootverbose) {
  74                 device_printf(b->dev, "sndbuf_setmap %lx, %lx; ",
  75                     (u_long)segs[0].ds_addr, (u_long)segs[0].ds_len);
  76                 printf("%p -> %lx\n", b->buf, (u_long)segs[0].ds_addr);
  77         }
  78         if (error == 0)
  79                 b->buf_addr = segs[0].ds_addr;
  80         else
  81                 b->buf_addr = 0;
  82 }
  83
  84 /*
  85  * Allocate memory for DMA buffer. If the device does not use DMA transfers,
  86  * the driver can call malloc(9) and sndbuf_setup() itself.
  87  */
  88
  89 int
  90 sndbuf_alloc(struct snd_dbuf *b, bus_dma_tag_t dmatag, int dmaflags,
  91     unsigned int size)
  92 {
  93         int ret;
  94
  95         b->dmatag = dmatag;
  96         b->dmaflags = dmaflags | BUS_DMA_NOWAIT;
  97         b->maxsize = size;
  98         b->bufsize = b->maxsize;
  99         b->buf_addr = 0;
 100         b->flags |= SNDBUF_F_MANAGED;
 101         if (bus_dmamem_alloc(b->dmatag, (void **)&b->buf, b->dmaflags,
 102             &b->dmamap)) {
 103                 sndbuf_free(b);
 104                 return (ENOMEM);
 105         }
 106         if (bus_dmamap_load(b->dmatag, b->dmamap, b->buf, b->maxsize,
 107             sndbuf_setmap, b, 0) != 0 || b->buf_addr == 0) {
 108                 sndbuf_free(b);
 109                 return (ENOMEM);
 110         }
 111
 112         ret = sndbuf_resize(b, 2, b->maxsize / 2);
 113         if (ret != 0)
 114                 sndbuf_free(b);
 115
 116         return (ret);
 117 }
 118
 119 int
 120 sndbuf_setup(struct snd_dbuf *b, void *buf, unsigned int size)
 121 {
 122         b->flags &= ~SNDBUF_F_MANAGED;
 123         if (buf)
 124                 b->flags |= SNDBUF_F_MANAGED;
 125         b->buf = buf;
 126         b->maxsize = size;
 127         b->bufsize = b->maxsize;
 128         return sndbuf_resize(b, 2, b->maxsize / 2);
 129 }
 130
 131 void
 132 sndbuf_free(struct snd_dbuf *b)
 133 {
 134         if (b->tmpbuf)
 135                 free(b->tmpbuf, M_DEVBUF);
 136
 137         if (b->shadbuf)
 138                 free(b->shadbuf, M_DEVBUF);
 139
 140         if (b->buf) {
 141                 if (b->flags & SNDBUF_F_MANAGED) {
 142                         if (b->dmamap)
 143                                 bus_dmamap_unload(b->dmatag, b->dmamap);
 144                         if (b->dmatag)
 145                                 bus_dmamem_free(b->dmatag, b->buf, b->dmamap);
 146                 } else
 147                         free(b->buf, M_DEVBUF);
 148         }
 149
 150         b->tmpbuf = NULL;
 151         b->shadbuf = NULL;
 152         b->buf = NULL;
 153         b->sl = 0;
 154         b->dmatag = NULL;
 155         b->dmamap = NULL;
 156 }
 157
 158 #define SNDBUF_CACHE_SHIFT      5
 159
 160 int
 161 sndbuf_resize(struct snd_dbuf *b, unsigned int blkcnt, unsigned int blksz)
 162 {
 163         unsigned int bufsize, allocsize;
 164         u_int8_t *tmpbuf;
 165
 166         CHN_LOCK(b->channel);
 167         if (b->maxsize == 0)
 168                 goto out;
 169         if (blkcnt == 0)
 170                 blkcnt = b->blkcnt;
 171         if (blksz == 0)
 172                 blksz = b->blksz;
 173         if (blkcnt < 2 || blksz < 16 || (blkcnt * blksz) > b->maxsize) {
 174                 CHN_UNLOCK(b->channel);
 175                 return EINVAL;
 176         }
 177         if (blkcnt == b->blkcnt && blksz == b->blksz)
 178                 goto out;
 179
 180         bufsize = blkcnt * blksz;
 181
 182         if (bufsize > b->allocsize ||
 183             bufsize < (b->allocsize >> SNDBUF_CACHE_SHIFT)) {
 184                 allocsize = round_page(bufsize);
 185                 CHN_UNLOCK(b->channel);
 186                 tmpbuf = malloc(allocsize, M_DEVBUF, M_WAITOK);
 187                 CHN_LOCK(b->channel);
 188                 if (snd_verbose > 3)
 189                         printf("%s(): b=%p %p -> %p [%d -> %d : %d]\n",
 190                             __func__, b, b->tmpbuf, tmpbuf,
 191                             b->allocsize, allocsize, bufsize);
 192                 if (b->tmpbuf != NULL)
 193                         free(b->tmpbuf, M_DEVBUF);
 194                 b->tmpbuf = tmpbuf;
 195                 b->allocsize = allocsize;
 196         } else if (snd_verbose > 3)
 197                 printf("%s(): b=%p %d [%d] NOCHANGE\n",
 198                     __func__, b, b->allocsize, b->bufsize);
 199
 200         b->blkcnt = blkcnt;
 201         b->blksz = blksz;
 202         b->bufsize = bufsize;
 203
 204         sndbuf_reset(b);
 205 out:
 206         CHN_UNLOCK(b->channel);
 207         return 0;
 208 }
 209
 210 int
 211 sndbuf_remalloc(struct snd_dbuf *b, unsigned int blkcnt, unsigned int blksz)
 212 {
 213         unsigned int bufsize, allocsize;
 214         u_int8_t *buf, *tmpbuf, *shadbuf;
 215
 216         if (blkcnt < 2 || blksz < 16)
 217                 return EINVAL;
 218
 219         bufsize = blksz * blkcnt;
 220
 221         if (bufsize > b->allocsize ||
 222             bufsize < (b->allocsize >> SNDBUF_CACHE_SHIFT)) {
 223                 allocsize = round_page(bufsize);
 224                 CHN_UNLOCK(b->channel);
 225                 buf = malloc(allocsize, M_DEVBUF, M_WAITOK);
 226                 tmpbuf = malloc(allocsize, M_DEVBUF, M_WAITOK);
 227                 shadbuf = malloc(allocsize, M_DEVBUF, M_WAITOK);
 228                 CHN_LOCK(b->channel);
 229                 if (b->buf != NULL)
 230                         free(b->buf, M_DEVBUF);
 231                 b->buf = buf;
 232                 if (b->tmpbuf != NULL)
 233                         free(b->tmpbuf, M_DEVBUF);
 234                 b->tmpbuf = tmpbuf;
 235                 if (b->shadbuf != NULL)
 236                         free(b->shadbuf, M_DEVBUF);
 237                 b->shadbuf = shadbuf;
 238                 if (snd_verbose > 3)
 239                         printf("%s(): b=%p %d -> %d [%d]\n",
 240                             __func__, b, b->allocsize, allocsize, bufsize);
 241                 b->allocsize = allocsize;
 242         } else if (snd_verbose > 3)
 243                 printf("%s(): b=%p %d [%d] NOCHANGE\n",
 244                     __func__, b, b->allocsize, b->bufsize);
 245
 246         b->blkcnt = blkcnt;
 247         b->blksz = blksz;
 248         b->bufsize = bufsize;
 249         b->maxsize = bufsize;
 250         b->sl = bufsize;
 251
 252         sndbuf_reset(b);
 253
 254         return 0;
 255 }
 256
 257 /**
 258  * @brief Zero out space in buffer free area
 259  *
 260  * This function clears a chunk of @c length bytes in the buffer free area
 261  * (i.e., where the next write will be placed).
 262  *
 263  * @param b             buffer context
 264  * @param length        number of bytes to blank
 265  */
 266 void
 267 sndbuf_clear(struct snd_dbuf *b, unsigned int length)
 268 {
 269         int i;
 270         u_char data, *p;
 271
 272         if (length == 0)
 273                 return;
 274         if (length > b->bufsize)
 275                 length = b->bufsize;
 276
 277         data = sndbuf_zerodata(b->fmt);
 278
 279         i = sndbuf_getfreeptr(b);
 280         p = sndbuf_getbuf(b);
 281         while (length > 0) {
 282                 p[i] = data;
 283                 length--;
 284                 i++;
 285                 if (i >= b->bufsize)
 286                         i = 0;
 287         }
 288 }
 289
 290 /**
 291  * @brief Zap buffer contents, resetting "ready area" fields
 292  *
 293  * @param b     buffer context
 294  */
 295 void
 296 sndbuf_fillsilence(struct snd_dbuf *b)
 297 {
 298         if (b->bufsize > 0)
 299                 memset(sndbuf_getbuf(b), sndbuf_zerodata(b->fmt), b->bufsize);
 300         b->rp = 0;
 301         b->rl = b->bufsize;
 302 }
 303
 304 /**
 305  * @brief Reset buffer w/o flushing statistics
 306  *
 307  * This function just zeroes out buffer contents and sets the "ready length"
 308  * to zero.  This was originally to facilitate minimal playback interruption
 309  * (i.e., dropped samples) in SNDCTL_DSP_SILENCE/SKIP ioctls.
 310  *
 311  * @param b     buffer context
 312  */
 313 void
 314 sndbuf_softreset(struct snd_dbuf *b)
 315 {
 316         b->rl = 0;
 317         if (b->buf && b->bufsize > 0)
 318                 sndbuf_clear(b, b->bufsize);
 319 }
 320
 321 void
 322 sndbuf_reset(struct snd_dbuf *b)
 323 {
 324         b->hp = 0;
 325         b->rp = 0;
 326         b->rl = 0;
 327         b->dl = 0;
 328         b->prev_total = 0;
 329         b->total = 0;
 330         b->xrun = 0;
 331         if (b->buf && b->bufsize > 0)
 332                 sndbuf_clear(b, b->bufsize);
 333         sndbuf_clearshadow(b);
 334 }
 335
 336 u_int32_t
 337 sndbuf_getfmt(struct snd_dbuf *b)
 338 {
 339         return b->fmt;
 340 }
 341
 342 int
 343 sndbuf_setfmt(struct snd_dbuf *b, u_int32_t fmt)
 344 {
 345         b->fmt = fmt;
 346         b->bps = AFMT_BPS(b->fmt);
 347         b->align = AFMT_ALIGN(b->fmt);
 348 #if 0
 349         b->bps = AFMT_CHANNEL(b->fmt);
 350         if (b->fmt & AFMT_16BIT)
 351                 b->bps <<= 1;
 352         else if (b->fmt & AFMT_24BIT)
 353                 b->bps *= 3;
 354         else if (b->fmt & AFMT_32BIT)
 355                 b->bps <<= 2;
 356 #endif
 357         return 0;
 358 }
 359
 360 unsigned int
 361 sndbuf_getspd(struct snd_dbuf *b)
 362 {
 363         return b->spd;
 364 }
 365
 366 void
 367 sndbuf_setspd(struct snd_dbuf *b, unsigned int spd)
 368 {
 369         b->spd = spd;
 370 }
 371
 372 unsigned int
 373 sndbuf_getalign(struct snd_dbuf *b)
 374 {
 375         return (b->align);
 376 }
 377
 378 unsigned int
 379 sndbuf_getblkcnt(struct snd_dbuf *b)
 380 {
 381         return b->blkcnt;
 382 }
 383
 384 void
 385 sndbuf_setblkcnt(struct snd_dbuf *b, unsigned int blkcnt)
 386 {
 387         b->blkcnt = blkcnt;
 388 }
 389
 390 unsigned int
 391 sndbuf_getblksz(struct snd_dbuf *b)
 392 {
 393         return b->blksz;
 394 }
 395
 396 void
 397 sndbuf_setblksz(struct snd_dbuf *b, unsigned int blksz)
 398 {
 399         b->blksz = blksz;
 400 }
 401
 402 unsigned int
 403 sndbuf_getbps(struct snd_dbuf *b)
 404 {
 405         return b->bps;
 406 }
 407
 408 void *
 409 sndbuf_getbuf(struct snd_dbuf *b)
 410 {
 411         return b->buf;
 412 }
 413
 414 void *
 415 sndbuf_getbufofs(struct snd_dbuf *b, unsigned int ofs)
 416 {
 417         KASSERT(ofs < b->bufsize, ("%s: ofs invalid %d", __func__, ofs));
 418
 419         return b->buf + ofs;
 420 }
 421
 422 unsigned int
 423 sndbuf_getsize(struct snd_dbuf *b)
 424 {
 425         return b->bufsize;
 426 }
 427
 428 unsigned int
 429 sndbuf_getmaxsize(struct snd_dbuf *b)
 430 {
 431         return b->maxsize;
 432 }
 433
 434 unsigned int
 435 sndbuf_getallocsize(struct snd_dbuf *b)
 436 {
 437         return b->allocsize;
 438 }
 439
 440 unsigned int
 441 sndbuf_runsz(struct snd_dbuf *b)
 442 {
 443         return b->dl;
 444 }
 445
 446 void
 447 sndbuf_setrun(struct snd_dbuf *b, int go)
 448 {
 449         b->dl = go? b->blksz : 0;
 450 }
 451
 452 struct selinfo *
 453 sndbuf_getsel(struct snd_dbuf *b)
 454 {
 455         return &b->sel;
 456 }
 457
 458 /************************************************************/
 459 unsigned int
 460 sndbuf_getxrun(struct snd_dbuf *b)
 461 {
 462         SNDBUF_LOCKASSERT(b);
 463
 464         return b->xrun;
 465 }
 466
 467 void
 468 sndbuf_setxrun(struct snd_dbuf *b, unsigned int xrun)
 469 {
 470         SNDBUF_LOCKASSERT(b);
 471
 472         b->xrun = xrun;
 473 }
 474
 475 unsigned int
 476 sndbuf_gethwptr(struct snd_dbuf *b)
 477 {
 478         SNDBUF_LOCKASSERT(b);
 479
 480         return b->hp;
 481 }
 482
 483 void
 484 sndbuf_sethwptr(struct snd_dbuf *b, unsigned int ptr)
 485 {
 486         SNDBUF_LOCKASSERT(b);
 487
 488         b->hp = ptr;
 489 }
 490
 491 unsigned int
 492 sndbuf_getready(struct snd_dbuf *b)
 493 {
 494         SNDBUF_LOCKASSERT(b);
 495         KASSERT((b->rl >= 0) && (b->rl <= b->bufsize), ("%s: b->rl invalid %d", __func__, b->rl));
 496
 497         return b->rl;
 498 }
 499
 500 unsigned int
 501 sndbuf_getreadyptr(struct snd_dbuf *b)
 502 {
 503         SNDBUF_LOCKASSERT(b);
 504         KASSERT((b->rp >= 0) && (b->rp <= b->bufsize), ("%s: b->rp invalid %d", __func__, b->rp));
 505
 506         return b->rp;
 507 }
 508
 509 unsigned int
 510 sndbuf_getfree(struct snd_dbuf *b)
 511 {
 512         SNDBUF_LOCKASSERT(b);
 513         KASSERT((b->rl >= 0) && (b->rl <= b->bufsize), ("%s: b->rl invalid %d", __func__, b->rl));
 514
 515         return b->bufsize - b->rl;
 516 }
 517
 518 unsigned int
 519 sndbuf_getfreeptr(struct snd_dbuf *b)
 520 {
 521         SNDBUF_LOCKASSERT(b);
 522         KASSERT((b->rp >= 0) && (b->rp <= b->bufsize), ("%s: b->rp invalid %d", __func__, b->rp));
 523         KASSERT((b->rl >= 0) && (b->rl <= b->bufsize), ("%s: b->rl invalid %d", __func__, b->rl));
 524
 525         return (b->rp + b->rl) % b->bufsize;
 526 }
 527
 528 u_int64_t
 529 sndbuf_getblocks(struct snd_dbuf *b)
 530 {
 531         SNDBUF_LOCKASSERT(b);
 532
 533         return b->total / b->blksz;
 534 }
 535
 536 u_int64_t
 537 sndbuf_getprevblocks(struct snd_dbuf *b)
 538 {
 539         SNDBUF_LOCKASSERT(b);
 540
 541         return b->prev_total / b->blksz;
 542 }
 543
 544 u_int64_t
 545 sndbuf_gettotal(struct snd_dbuf *b)
 546 {
 547         SNDBUF_LOCKASSERT(b);
 548
 549         return b->total;
 550 }
 551
 552 u_int64_t
 553 sndbuf_getprevtotal(struct snd_dbuf *b)
 554 {
 555         SNDBUF_LOCKASSERT(b);
 556
 557         return b->prev_total;
 558 }
 559
 560 void
 561 sndbuf_updateprevtotal(struct snd_dbuf *b)
 562 {
 563         SNDBUF_LOCKASSERT(b);
 564
 565         b->prev_total = b->total;
 566 }
 567
 568 unsigned int
 569 sndbuf_xbytes(unsigned int v, struct snd_dbuf *from, struct snd_dbuf *to)
 570 {
 571         if (from == NULL || to == NULL || v == 0)
 572                 return 0;
 573
 574         return snd_xbytes(v, sndbuf_getalign(from) * sndbuf_getspd(from),
 575             sndbuf_getalign(to) * sndbuf_getspd(to));
 576 }
 577
 578 u_int8_t
 579 sndbuf_zerodata(u_int32_t fmt)
 580 {
 581         if (fmt & (AFMT_SIGNED | AFMT_PASSTHROUGH))
 582                 return (0x00);
 583         else if (fmt & AFMT_MU_LAW)
 584                 return (0x7f);
 585         else if (fmt & AFMT_A_LAW)
 586                 return (0x55);
 587         return (0x80);
 588 }
 589
 590 /************************************************************/
 591
 592 /**
 593  * @brief Acquire buffer space to extend ready area
 594  *
 595  * This function extends the ready area length by @c count bytes, and may
 596  * optionally copy samples from another location stored in @c from.  The
 597  * counter @c snd_dbuf::total is also incremented by @c count bytes.
 598  *
 599  * @param b     audio buffer
 600  * @param from  sample source (optional)
 601  * @param count number of bytes to acquire
 602  *
 603  * @retval 0    Unconditional
 604  */
 605 int
 606 sndbuf_acquire(struct snd_dbuf *b, u_int8_t *from, unsigned int count)
 607 {
 608         int l;
 609
 610         KASSERT(count <= sndbuf_getfree(b), ("%s: count %d > free %d", __func__, count, sndbuf_getfree(b)));
 611         KASSERT((b->rl >= 0) && (b->rl <= b->bufsize), ("%s: b->rl invalid %d", __func__, b->rl));
 612         b->total += count;
 613         if (from != NULL) {
 614                 while (count > 0) {
 615                         l = min(count, sndbuf_getsize(b) - sndbuf_getfreeptr(b));
 616                         bcopy(from, sndbuf_getbufofs(b, sndbuf_getfreeptr(b)), l);
 617                         from += l;
 618                         b->rl += l;
 619                         count -= l;
 620                 }
 621         } else
 622                 b->rl += count;
 623         KASSERT((b->rl >= 0) && (b->rl <= b->bufsize), ("%s: b->rl invalid %d, count %d", __func__, b->rl, count));
 624
 625         return 0;
 626 }
 627
 628 /**
 629  * @brief Dispose samples from channel buffer, increasing size of ready area
 630  *
 631  * This function discards samples from the supplied buffer by advancing the
 632  * ready area start pointer and decrementing the ready area length.  If
 633  * @c to is not NULL, then the discard samples will be copied to the location
 634  * it points to.
 635  *
 636  * @param b     PCM channel sound buffer
 637  * @param to    destination buffer (optional)
 638  * @param count number of bytes to discard
 639  *
 640  * @returns 0 unconditionally
 641  */
 642 int
 643 sndbuf_dispose(struct snd_dbuf *b, u_int8_t *to, unsigned int count)
 644 {
 645         int l;
 646
 647         KASSERT(count <= sndbuf_getready(b), ("%s: count %d > ready %d", __func__, count, sndbuf_getready(b)));
 648         KASSERT((b->rl >= 0) && (b->rl <= b->bufsize), ("%s: b->rl invalid %d", __func__, b->rl));
 649         if (to != NULL) {
 650                 while (count > 0) {
 651                         l = min(count, sndbuf_getsize(b) - sndbuf_getreadyptr(b));
 652                         bcopy(sndbuf_getbufofs(b, sndbuf_getreadyptr(b)), to, l);
 653                         to += l;
 654                         b->rl -= l;
 655                         b->rp = (b->rp + l) % b->bufsize;
 656                         count -= l;
 657                 }
 658         } else {
 659                 b->rl -= count;
 660                 b->rp = (b->rp + count) % b->bufsize;
 661         }
 662         KASSERT((b->rl >= 0) && (b->rl <= b->bufsize), ("%s: b->rl invalid %d, count %d", __func__, b->rl, count));
 663
 664         return 0;
 665 }
 666
 667 #ifdef SND_DIAGNOSTIC
 668 static uint32_t snd_feeder_maxfeed = 0;
 669 SYSCTL_INT(_hw_snd, OID_AUTO, feeder_maxfeed, CTLFLAG_RD,
 670     &snd_feeder_maxfeed, 0, "maximum feeder count request");
 671
 672 static uint32_t snd_feeder_maxcycle = 0;
 673 SYSCTL_INT(_hw_snd, OID_AUTO, feeder_maxcycle, CTLFLAG_RD,
 674     &snd_feeder_maxcycle, 0, "maximum feeder cycle");
 675 #endif
 676
 677 /* count is number of bytes we want added to destination buffer */
 678 int
 679 sndbuf_feed(struct snd_dbuf *from, struct snd_dbuf *to, struct pcm_channel *channel, struct pcm_feeder *feeder, unsigned int count)
 680 {
 681         unsigned int cnt, maxfeed;
 682 #ifdef SND_DIAGNOSTIC
 683         unsigned int cycle;
 684
 685         if (count > snd_feeder_maxfeed)
 686                 snd_feeder_maxfeed = count;
 687
 688         cycle = 0;
 689 #endif
 690
 691         KASSERT(count > 0, ("can't feed 0 bytes"));
 692
 693         if (sndbuf_getfree(to) < count)
 694                 return (EINVAL);
 695
 696         maxfeed = SND_FXROUND(SND_FXDIV_MAX, sndbuf_getalign(to));
 697
 698         do {
 699                 cnt = FEEDER_FEED(feeder, channel, to->tmpbuf,
 700                     min(count, maxfeed), from);
 701                 if (cnt == 0)
 702                         break;
 703                 sndbuf_acquire(to, to->tmpbuf, cnt);
 704                 count -= cnt;
 705 #ifdef SND_DIAGNOSTIC
 706                 cycle++;
 707 #endif
 708         } while (count != 0);
 709
 710 #ifdef SND_DIAGNOSTIC
 711         if (cycle > snd_feeder_maxcycle)
 712                 snd_feeder_maxcycle = cycle;
 713 #endif
 714
 715         return (0);
 716 }
 717
 718 /************************************************************/
 719
 720 void
 721 sndbuf_dump(struct snd_dbuf *b, char *s, u_int32_t what)
 722 {
 723         printf("%s: [", s);
 724         if (what & 0x01)
 725                 printf(" bufsize: %d, maxsize: %d", b->bufsize, b->maxsize);
 726         if (what & 0x02)
 727                 printf(" dl: %d, rp: %d, rl: %d, hp: %d", b->dl, b->rp, b->rl, b->hp);
 728         if (what & 0x04)
 729                 printf(" total: %ju, prev_total: %ju, xrun: %d", (uintmax_t)b->total, (uintmax_t)b->prev_total, b->xrun);
 730         if (what & 0x08)
 731                 printf(" fmt: 0x%x, spd: %d", b->fmt, b->spd);
 732         if (what & 0x10)
 733                 printf(" blksz: %d, blkcnt: %d, flags: 0x%x", b->blksz, b->blkcnt, b->flags);
 734         printf(" ]\n");
 735 }
 736
 737 /************************************************************/
 738 u_int32_t
 739 sndbuf_getflags(struct snd_dbuf *b)
 740 {
 741         return b->flags;
 742 }
 743
 744 void
 745 sndbuf_setflags(struct snd_dbuf *b, u_int32_t flags, int on)
 746 {
 747         b->flags &= ~flags;
 748         if (on)
 749                 b->flags |= flags;
 750 }
 751
 752 /**
 753  * @brief Clear the shadow buffer by filling with samples equal to zero.
 754  *
 755  * @param b buffer to clear
 756  */
 757 void
 758 sndbuf_clearshadow(struct snd_dbuf *b)
 759 {
 760         KASSERT(b != NULL, ("b is a null pointer"));
 761         KASSERT(b->sl >= 0, ("illegal shadow length"));
 762
 763         if ((b->shadbuf != NULL) && (b->sl > 0))
 764                 memset(b->shadbuf, sndbuf_zerodata(b->fmt), b->sl);
 765 }
 766
 767 #ifdef OSSV4_EXPERIMENT
 768 /**
 769  * @brief Return peak value from samples in buffer ready area.
 770  *
 771  * Peak ranges from 0-32767.  If channel is monaural, most significant 16
 772  * bits will be zero.  For now, only expects to work with 1-2 channel
 773  * buffers.
 774  *
 775  * @note  Currently only operates with linear PCM formats.
 776  *
 777  * @param b buffer to analyze
 778  * @param lpeak pointer to store left peak value
 779  * @param rpeak pointer to store right peak value
 780  */
 781 void
 782 sndbuf_getpeaks(struct snd_dbuf *b, int *lp, int *rp)
 783 {
 784         u_int32_t lpeak, rpeak;
 785
 786         lpeak = 0;
 787         rpeak = 0;
 788
 789         /**
 790          * @todo fill this in later
 791          */
 792 }
 793 #endif