sys/dev/sound/pcm/buffer.c

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