diff --git a/sys/arm/allwinner/a10_codec.c b/sys/arm/allwinner/a10_codec.c
--- a/sys/arm/allwinner/a10_codec.c
+++ b/sys/arm/allwinner/a10_codec.c
@@ -680,7 +680,7 @@
 	struct a10codec_chinfo *ch = priv;
 	unsigned bufsize;
 
-	bufsize = sndbuf_getsize(ch->buffer);
+	bufsize = ch->buffer->bufsize;
 
 	ch->pos += ch->blocksize;
 	if (ch->pos >= bufsize)
diff --git a/sys/arm/allwinner/aw_i2s.c b/sys/arm/allwinner/aw_i2s.c
--- a/sys/arm/allwinner/aw_i2s.c
+++ b/sys/arm/allwinner/aw_i2s.c
@@ -530,10 +530,10 @@
 		val  = I2S_READ(sc, DA_FSTA);
 		empty = DA_FSTA_TXE_CNT(val);
 		count = sndbuf_getready(play_buf);
-		size = sndbuf_getsize(play_buf);
+		size = play_buf->bufsize;
 		readyptr = sndbuf_getreadyptr(play_buf);
 
-		samples = (uint8_t*)sndbuf_getbuf(play_buf);
+		samples = play_buf->buf;
 		written = 0;
 		if (empty > count / 2)
 			empty = count / 2;
@@ -556,9 +556,9 @@
 		available = DA_FSTA_RXA_CNT(val);
 
 		count = sndbuf_getfree(rec_buf);
-		size = sndbuf_getsize(rec_buf);
+		size = rec_buf->bufsize;
 		freeptr = sndbuf_getfreeptr(rec_buf);
-		samples = (uint8_t*)sndbuf_getbuf(rec_buf);
+		samples = rec_buf->buf;
 		recorded = 0;
 		if (available > count / 2)
 			available = count / 2;
diff --git a/sys/arm/broadcom/bcm2835/bcm2835_audio.c b/sys/arm/broadcom/bcm2835/bcm2835_audio.c
--- a/sys/arm/broadcom/bcm2835/bcm2835_audio.c
+++ b/sys/arm/broadcom/bcm2835/bcm2835_audio.c
@@ -575,7 +575,7 @@
 			continue;
 
 		count = sndbuf_getready(ch->buffer);
-		size = sndbuf_getsize(ch->buffer);
+		size = ch->buffer->bufsize;
 		readyptr = sndbuf_getreadyptr(ch->buffer);
 
 		BCM2835_AUDIO_LOCK(sc);
@@ -588,11 +588,12 @@
 		if (count < VCHIQ_AUDIO_PACKET_SIZE)
 			continue;
 
-		buf = (uint8_t*)sndbuf_getbuf(ch->buffer) + readyptr;
+		buf = ch->buffer->buf + readyptr;
 
 		bcm2835_audio_write_samples(ch, buf, count);
 		BCM2835_AUDIO_LOCK(sc);
-		ch->unsubmittedptr = (ch->unsubmittedptr + count) % sndbuf_getsize(ch->buffer);
+		ch->unsubmittedptr = (ch->unsubmittedptr + count) %
+		    ch->buffer->bufsize;
 		ch->available_space -= count;
 		ch->submitted_samples += count;
 		KASSERT(ch->available_space >= 0, ("ch->available_space == %d\n", ch->available_space));
@@ -662,7 +663,7 @@
 	struct bcm2835_audio_chinfo *ch = data;
 	void *buffer;
 
-	buffer = sndbuf_getbuf(ch->buffer);
+	buffer = ch->buffer->buf;
 	if (buffer)
 		free(buffer, M_DEVBUF);
 
diff --git a/sys/arm/freescale/imx/imx6_ssi.c b/sys/arm/freescale/imx/imx6_ssi.c
--- a/sys/arm/freescale/imx/imx6_ssi.c
+++ b/sys/arm/freescale/imx/imx6_ssi.c
@@ -398,7 +398,7 @@
 
 	setup_dma(scp);
 
-	return (sndbuf_getblksz(ch->buffer));
+	return (ch->buffer->blksz);
 }
 
 uint32_t
@@ -415,7 +415,7 @@
 	sc = scp->sc;
 	conf = sc->conf;
 
-	bufsize = sndbuf_getsize(ch->buffer);
+	bufsize = ch->buffer->bufsize;
 
 	sc->pos += conf->period;
 	if (sc->pos >= bufsize)
@@ -487,8 +487,8 @@
 	conf->saddr = sc->buf_base_phys;
 	conf->daddr = rman_get_start(sc->res[0]) + SSI_STX0;
 	conf->event = sc->sdma_ev_tx; /* SDMA TX event */
-	conf->period = sndbuf_getblksz(ch->buffer);
-	conf->num_bd = sndbuf_getblkcnt(ch->buffer);
+	conf->period = ch->buffer->blksz;
+	conf->num_bd = ch->buffer->blkcnt;
 
 	/*
 	 * Word Length
@@ -497,7 +497,7 @@
 	 * SSI supports 24 at max.
 	 */
 
-	fmt = sndbuf_getfmt(ch->buffer);
+	fmt = ch->buffer->fmt;
 
 	if (fmt & AFMT_16BIT) {
 		conf->word_length = 16;
diff --git a/sys/arm/freescale/vybrid/vf_sai.c b/sys/arm/freescale/vybrid/vf_sai.c
--- a/sys/arm/freescale/vybrid/vf_sai.c
+++ b/sys/arm/freescale/vybrid/vf_sai.c
@@ -369,7 +369,7 @@
 
 	sndbuf_resize(ch->buffer, sc->dma_size / blocksize, blocksize);
 
-	sc->period = sndbuf_getblksz(ch->buffer);
+	sc->period = ch->buffer->blksz;
 	return (sc->period);
 }
 
diff --git a/sys/arm64/rockchip/rk_i2s.c b/sys/arm64/rockchip/rk_i2s.c
--- a/sys/arm64/rockchip/rk_i2s.c
+++ b/sys/arm64/rockchip/rk_i2s.c
@@ -403,10 +403,10 @@
 		count = sndbuf_getready(play_buf);
 		if (count > FIFO_SIZE - 1)
 			count = FIFO_SIZE - 1;
-		size = sndbuf_getsize(play_buf);
+		size = play_buf->bufsize;
 		readyptr = sndbuf_getreadyptr(play_buf);
 
-		samples = (uint8_t*)sndbuf_getbuf(play_buf);
+		samples = play_buf->buf;
 		written = 0;
 		for (; level < count; level++) {
 			val  = (samples[readyptr++ % size] << 0);
@@ -426,9 +426,9 @@
 		uint8_t *samples;
 		uint32_t count, size, freeptr, recorded;
 		count = sndbuf_getfree(rec_buf);
-		size = sndbuf_getsize(rec_buf);
+		size = rec_buf->bufsize;
 		freeptr = sndbuf_getfreeptr(rec_buf);
-		samples = (uint8_t*)sndbuf_getbuf(rec_buf);
+		samples = rec_buf->buf;
 		recorded = 0;
 		if (level > count / 4)
 			level = count / 4;
diff --git a/sys/dev/sound/dummy.c b/sys/dev/sound/dummy.c
--- a/sys/dev/sound/dummy.c
+++ b/sys/dev/sound/dummy.c
@@ -105,8 +105,8 @@
 		if (!ch->run)
 			continue;
 		if (ch->dir == PCMDIR_PLAY) {
-			ch->ptr += sndbuf_getblksz(ch->buf);
-			ch->ptr %= sndbuf_getsize(ch->buf);
+			ch->ptr += ch->buf->blksz;
+			ch->ptr %= ch->buf->bufsize;
 		} else
 			sndbuf_fillsilence(ch->buf);
 		snd_mtxunlock(sc->lock);
@@ -123,7 +123,7 @@
 	struct dummy_chan *ch =data;
 	uint8_t *buf;
 
-	buf = sndbuf_getbuf(ch->buf);
+	buf = ch->buf->buf;
 	if (buf != NULL)
 		free(buf, M_DEVBUF);
 
@@ -190,7 +190,7 @@
 {
 	struct dummy_chan *ch = data;
 
-	return (sndbuf_getblksz(ch->buf));
+	return (ch->buf->blksz);
 }
 
 static int
diff --git a/sys/dev/sound/fdt/audio_soc.c b/sys/dev/sound/fdt/audio_soc.c
--- a/sys/dev/sound/fdt/audio_soc.c
+++ b/sys/dev/sound/fdt/audio_soc.c
@@ -249,7 +249,7 @@
 
 	ausoc_chan = (struct audio_soc_channel *)data;
 
-	buffer = sndbuf_getbuf(ausoc_chan->buf);
+	buffer = ausoc_chan->buf->buf;
 	if (buffer)
 		free(buffer, M_DEVBUF);
 
diff --git a/sys/dev/sound/macio/aoa.c b/sys/dev/sound/macio/aoa.c
--- a/sys/dev/sound/macio/aoa.c
+++ b/sys/dev/sound/macio/aoa.c
@@ -73,8 +73,8 @@
 	u_int32_t 		 addr;
 	int 			 i;
 
-	addr = (u_int32_t) sndbuf_getbufaddr(dma->buf);
-	KASSERT(dma->bufsz == sndbuf_getsize(dma->buf), ("bad size"));
+	addr = (u_int32_t)dma->buf->buf_addr;
+	KASSERT(dma->bufsz == dma->buf->bufsize, ("bad size"));
 
 	dma->slots = dma->bufsz / dma->blksz;
 
diff --git a/sys/dev/sound/pci/als4000.c b/sys/dev/sound/pci/als4000.c
--- a/sys/dev/sound/pci/als4000.c
+++ b/sys/dev/sound/pci/als4000.c
@@ -281,7 +281,7 @@
 	snd_mtxlock(sc->lock);
 	pos = als_gcr_rd(ch->parent, ch->gcr_fifo_status) & 0xffff;
 	snd_mtxunlock(sc->lock);
-	sz  = sndbuf_getsize(ch->buffer);
+	sz  = ch->buffer->bufsize;
 	return (2 * sz - pos - 1) % sz;
 }
 
@@ -348,8 +348,8 @@
 	struct	sc_info *sc = ch->parent;
 	u_int32_t	buf, bufsz, count, dma_prog;
 
-	buf = sndbuf_getbufaddr(ch->buffer);
-	bufsz = sndbuf_getsize(ch->buffer);
+	buf = ch->buffer->buf_addr;
+	bufsz = ch->buffer->bufsize;
 	count = bufsz / 2;
 	if (ch->format & AFMT_16BIT)
 		count /= 2;
@@ -451,8 +451,8 @@
 	struct	sc_info *sc = ch->parent;
 	u_int32_t	buf, bufsz, count, dma_prog;
 
-	buf = sndbuf_getbufaddr(ch->buffer);
-	bufsz = sndbuf_getsize(ch->buffer);
+	buf = ch->buffer->buf_addr;
+	bufsz = ch->buffer->bufsize;
 	count = bufsz / 2;
 	if (ch->format & AFMT_16BIT)
 		count /= 2;
diff --git a/sys/dev/sound/pci/atiixp.c b/sys/dev/sound/pci/atiixp.c
--- a/sys/dev/sound/pci/atiixp.c
+++ b/sys/dev/sound/pci/atiixp.c
@@ -535,8 +535,8 @@
 
 	blksz &= ATI_IXP_BLK_ALIGN;
 
-	if (blksz > (sndbuf_getmaxsize(ch->buffer) / ATI_IXP_DMA_CHSEGS_MIN))
-		blksz = sndbuf_getmaxsize(ch->buffer) / ATI_IXP_DMA_CHSEGS_MIN;
+	if (blksz > (ch->buffer->maxsize / ATI_IXP_DMA_CHSEGS_MIN))
+		blksz = ch->buffer->maxsize / ATI_IXP_DMA_CHSEGS_MIN;
 	if (blksz < ATI_IXP_BLK_MIN)
 		blksz = ATI_IXP_BLK_MIN;
 	if (blkcnt > ATI_IXP_DMA_CHSEGS_MAX)
@@ -544,7 +544,7 @@
 	if (blkcnt < ATI_IXP_DMA_CHSEGS_MIN)
 		blkcnt = ATI_IXP_DMA_CHSEGS_MIN;
 
-	while ((blksz * blkcnt) > sndbuf_getmaxsize(ch->buffer)) {
+	while ((blksz * blkcnt) > ch->buffer->maxsize) {
 		if ((blkcnt >> 1) >= ATI_IXP_DMA_CHSEGS_MIN)
 			blkcnt >>= 1;
 		else if ((blksz >> 1) >= ATI_IXP_BLK_MIN)
@@ -553,14 +553,14 @@
 			break;
 	}
 
-	if ((sndbuf_getblksz(ch->buffer) != blksz ||
-	    sndbuf_getblkcnt(ch->buffer) != blkcnt) &&
+	if ((ch->buffer->blksz != blksz ||
+	    ch->buffer->blkcnt != blkcnt) &&
 	    sndbuf_resize(ch->buffer, blkcnt, blksz) != 0)
 		device_printf(sc->dev, "%s: failed blksz=%u blkcnt=%u\n",
 		    __func__, blksz, blkcnt);
 
-	ch->blksz = sndbuf_getblksz(ch->buffer);
-	ch->blkcnt = sndbuf_getblkcnt(ch->buffer);
+	ch->blksz = ch->buffer->blksz;
+	ch->blkcnt = ch->buffer->blkcnt;
 
 	return (0);
 }
@@ -583,7 +583,7 @@
 	uint32_t addr, blksz, blkcnt;
 	int i;
 
-	addr = sndbuf_getbufaddr(ch->buffer);
+	addr = ch->buffer->buf_addr;
 
 	if (sc->polling != 0) {
 		blksz = ch->blksz * ch->blkcnt;
@@ -610,7 +610,7 @@
 	volatile uint32_t ptr;
 
 	reg = ch->dt_cur_bit;
-	addr = sndbuf_getbufaddr(ch->buffer);
+	addr = ch->buffer->buf_addr;
 	sz = ch->blkcnt * ch->blksz;
 	retry = ATI_IXP_DMA_RETRY_MAX;
 
@@ -739,8 +739,7 @@
 			ch->ptr = 0;
 			ch->prevptr = 0;
 			pollticks = ((uint64_t)hz * ch->blksz) /
-			    ((uint64_t)sndbuf_getalign(ch->buffer) *
-			    sndbuf_getspd(ch->buffer));
+			    ((uint64_t)ch->buffer->align * ch->buffer->spd);
 			pollticks >>= 2;
 			if (pollticks > hz)
 				pollticks = hz;
@@ -781,8 +780,8 @@
 				else
 					ch = &sc->rch;
 				pollticks = ((uint64_t)hz * ch->blksz) /
-				    ((uint64_t)sndbuf_getalign(ch->buffer) *
-				    sndbuf_getspd(ch->buffer));
+				    ((uint64_t)ch->buffer->align *
+				    ch->buffer->spd);
 				pollticks >>= 2;
 				if (pollticks > hz)
 					pollticks = hz;
diff --git a/sys/dev/sound/pci/cmi.c b/sys/dev/sound/pci/cmi.c
--- a/sys/dev/sound/pci/cmi.c
+++ b/sys/dev/sound/pci/cmi.c
@@ -255,10 +255,10 @@
 {
 	u_int32_t s, i, sz;
 
-	ch->phys_buf = sndbuf_getbufaddr(ch->buffer);
+	ch->phys_buf = ch->buffer->buf_addr;
 
 	cmi_wr(sc, base, ch->phys_buf, 4);
-	sz = (u_int32_t)sndbuf_getsize(ch->buffer);
+	sz = (u_int32_t)ch->buffer->bufsize;
 
 	s = sz / ch->bps - 1;
 	cmi_wr(sc, base + 4, s, 2);
@@ -525,7 +525,7 @@
 	}
 	snd_mtxunlock(sc->lock);
 
-	sz = sndbuf_getsize(ch->buffer);
+	sz = ch->buffer->bufsize;
 	bufptr = (physptr - ch->phys_buf + sz - ch->bps) % sz;
 
 	return bufptr;
diff --git a/sys/dev/sound/pci/cs4281.c b/sys/dev/sound/pci/cs4281.c
--- a/sys/dev/sound/pci/cs4281.c
+++ b/sys/dev/sound/pci/cs4281.c
@@ -328,7 +328,7 @@
     ch->fmt = SND_FORMAT(AFMT_U8, 1, 0);
     ch->spd = DSP_DEFAULT_SPEED;
     ch->bps = 1;
-    ch->blksz = sndbuf_getsize(ch->buffer);
+    ch->blksz = ch->buffer->bufsize;
 
     ch->dma_chan = (dir == PCMDIR_PLAY) ? CS4281_DMA_PLAY : CS4281_DMA_REC;
     ch->dma_setup = 0;
@@ -412,7 +412,7 @@
     u_int32_t  dba, dca, ptr;
     int sz;
 
-    sz  = sndbuf_getsize(ch->buffer);
+    sz  = ch->buffer->bufsize;
     dba = cs4281_rd(sc, CS4281PCI_DBA(ch->dma_chan));
     dca = cs4281_rd(sc, CS4281PCI_DCA(ch->dma_chan));
     ptr = (dca - dba + sz) % sz;
@@ -493,9 +493,9 @@
     if (!ch->dma_setup) {
 	go = adcdac_go(ch, 0);
 	cs4281_wr(sc, CS4281PCI_DBA(ch->dma_chan),
-		  sndbuf_getbufaddr(ch->buffer));
+		  ch->buffer->buf_addr);
 	cs4281_wr(sc, CS4281PCI_DBC(ch->dma_chan),
-		  sndbuf_getsize(ch->buffer) / ch->bps - 1);
+		  ch->buffer->bufsize / ch->bps - 1);
 	ch->dma_setup = 1;
 	adcdac_go(ch, go);
     }
diff --git a/sys/dev/sound/pci/csapcm.c b/sys/dev/sound/pci/csapcm.c
--- a/sys/dev/sound/pci/csapcm.c
+++ b/sys/dev/sound/pci/csapcm.c
@@ -483,7 +483,7 @@
 
 	if (ch->dir == PCMDIR_PLAY) {
 		/* direction */
-		csa_writemem(resp, BA1_PBA, sndbuf_getbufaddr(ch->buffer));
+		csa_writemem(resp, BA1_PBA, ch->buffer->buf_addr);
 
 		/* format */
 		csa->pfie = csa_readmem(resp, BA1_PFIE) & ~0x0000f03f;
@@ -512,7 +512,7 @@
 		csa_setplaysamplerate(resp, ch->spd);
 	} else if (ch->dir == PCMDIR_REC) {
 		/* direction */
-		csa_writemem(resp, BA1_CBA, sndbuf_getbufaddr(ch->buffer));
+		csa_writemem(resp, BA1_CBA, ch->buffer->buf_addr);
 
 		/* format */
 		csa_writemem(resp, BA1_CIE, (csa_readmem(resp, BA1_CIE) & ~0x0000003f) | 0x00000001);
@@ -602,11 +602,11 @@
 	resp = &csa->res;
 
 	if (ch->dir == PCMDIR_PLAY) {
-		ptr = csa_readmem(resp, BA1_PBA) - sndbuf_getbufaddr(ch->buffer);
+		ptr = csa_readmem(resp, BA1_PBA) - ch->buffer->buf_addr;
 		if ((ch->fmt & AFMT_U8) != 0 || (ch->fmt & AFMT_S8) != 0)
 			ptr >>= 1;
 	} else {
-		ptr = csa_readmem(resp, BA1_CBA) - sndbuf_getbufaddr(ch->buffer);
+		ptr = csa_readmem(resp, BA1_CBA) - ch->buffer->buf_addr;
 		if ((ch->fmt & AFMT_U8) != 0 || (ch->fmt & AFMT_S8) != 0)
 			ptr >>= 1;
 	}
diff --git a/sys/dev/sound/pci/emu10k1.c b/sys/dev/sound/pci/emu10k1.c
--- a/sys/dev/sound/pci/emu10k1.c
+++ b/sys/dev/sound/pci/emu10k1.c
@@ -413,7 +413,7 @@
 	for (i = 0; i < sc->nchans; i++) {
 		pch = &sc->pch[i];
 		if (pch->buffer) {
-			tmp = (pch->spd * sndbuf_getalign(pch->buffer))
+			tmp = (pch->spd * pch->buffer->align)
 			    / pch->blksz;
 			if (tmp > rate)
 				rate = tmp;
@@ -423,7 +423,7 @@
 	for (i = 0; i < 3; i++) {
 		rch = &sc->rch[i];
 		if (rch->buffer) {
-			tmp = (rch->spd * sndbuf_getalign(rch->buffer))
+			tmp = (rch->spd * rch->buffer->align)
 			    / rch->blksz;
 			if (tmp > rate)
 				rate = tmp;
@@ -838,7 +838,7 @@
 	int r;
 
 	snd_mtxlock(sc->lock);
-	r = emu_memfree(sc, sndbuf_getbuf(ch->buffer));
+	r = emu_memfree(sc, ch->buffer->buf);
 	snd_mtxunlock(sc->lock);
 
 	return r;
@@ -985,7 +985,7 @@
 		return NULL;
 	else {
 		snd_mtxlock(sc->lock);
-		emu_wrptr(sc, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
+		emu_wrptr(sc, 0, ch->basereg, ch->buffer->buf_addr);
 		emu_wrptr(sc, 0, ch->sizereg, 0); /* off */
 		snd_mtxunlock(sc->lock);
 		return ch;
diff --git a/sys/dev/sound/pci/emu10kx-pcm.c b/sys/dev/sound/pci/emu10kx-pcm.c
--- a/sys/dev/sound/pci/emu10kx-pcm.c
+++ b/sys/dev/sound/pci/emu10kx-pcm.c
@@ -773,7 +773,7 @@
 		blocksize = ch->pcm->bufsz;
 	snd_mtxlock(sc->lock);
 	ch->blksz = blocksize;
-	emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
+	emu_timer_set(sc->card, ch->timer, ch->blksz / ch->buffer->align);
 	snd_mtxunlock(sc->lock);
 	return (ch->blksz);
 }
@@ -795,7 +795,8 @@
 		else
 			emu_vroute(sc->card, &(sc->rt_mono), ch->master);
 		emu_vwrite(sc->card, ch->master);
-		emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
+		emu_timer_set(sc->card, ch->timer, ch->blksz /
+		    ch->buffer->align);
 		emu_timer_enable(sc->card, ch->timer, 1);
 	}
 	/* PCM interrupt handler will handle PCMTRIG_STOP event */
@@ -878,7 +879,7 @@
 		return (NULL);
 	else {
 		ch->timer = emu_timer_create(sc->card);
-		emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
+		emu_wrptr(sc->card, 0, ch->basereg, ch->buffer->buf_addr);
 		emu_wrptr(sc->card, 0, ch->sizereg, 0);	/* off */
 		return (ch);
 	}
@@ -930,7 +931,8 @@
 	 * (and use) timer interrupts. Otherwise channel will be marked dead.
 	 */
 	if (ch->blksz < (ch->pcm->bufsz / 2)) {
-		emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
+		emu_timer_set(sc->card, ch->timer, ch->blksz /
+		    ch->buffer->align);
 		emu_timer_enable(sc->card, ch->timer, 1);
 	} else {
 		emu_timer_enable(sc->card, ch->timer, 0);
@@ -1059,7 +1061,7 @@
 	if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
 		return (NULL);
 	else {
-		emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
+		emu_wrptr(sc->card, 0, ch->basereg, ch->buffer->buf_addr);
 		emu_wrptr(sc->card, 0, ch->sizereg, 0);	/* off */
 		return (ch);
 	}
diff --git a/sys/dev/sound/pci/es137x.c b/sys/dev/sound/pci/es137x.c
--- a/sys/dev/sound/pci/es137x.c
+++ b/sys/dev/sound/pci/es137x.c
@@ -508,21 +508,21 @@
 			es_wr(es, ES1370_REG_MEMPAGE,
 			    ES1370_REG_DAC1_FRAMEADR >> 8, 1);
 			es_wr(es, ES1370_REG_DAC1_FRAMEADR & 0xff,
-			    sndbuf_getbufaddr(ch->buffer), 4);
+			    ch->buffer->buf_addr, 4);
 			es_wr(es, ES1370_REG_DAC1_FRAMECNT & 0xff,
 			    (ch->bufsz >> 2) - 1, 4);
 		} else {
 			es_wr(es, ES1370_REG_MEMPAGE,
 			    ES1370_REG_DAC2_FRAMEADR >> 8, 1);
 			es_wr(es, ES1370_REG_DAC2_FRAMEADR & 0xff,
-			    sndbuf_getbufaddr(ch->buffer), 4);
+			    ch->buffer->buf_addr, 4);
 			es_wr(es, ES1370_REG_DAC2_FRAMECNT & 0xff,
 			    (ch->bufsz >> 2) - 1, 4);
 		}
 	} else {
 		es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_ADC_FRAMEADR >> 8, 1);
 		es_wr(es, ES1370_REG_ADC_FRAMEADR & 0xff,
-		    sndbuf_getbufaddr(ch->buffer), 4);
+		    ch->buffer->buf_addr, 4);
 		es_wr(es, ES1370_REG_ADC_FRAMECNT & 0xff,
 		    (ch->bufsz >> 2) - 1, 4);
 	}
@@ -637,8 +637,8 @@
 
 	blksz &= ES_BLK_ALIGN;
 
-	if (blksz > (sndbuf_getmaxsize(ch->buffer) / ES_DMA_SEGS_MIN))
-		blksz = sndbuf_getmaxsize(ch->buffer) / ES_DMA_SEGS_MIN;
+	if (blksz > (ch->buffer->maxsize / ES_DMA_SEGS_MIN))
+		blksz = ch->buffer->maxsize / ES_DMA_SEGS_MIN;
 	if (blksz < ES_BLK_MIN)
 		blksz = ES_BLK_MIN;
 	if (blkcnt > ES_DMA_SEGS_MAX)
@@ -646,7 +646,7 @@
 	if (blkcnt < ES_DMA_SEGS_MIN)
 		blkcnt = ES_DMA_SEGS_MIN;
 
-	while ((blksz * blkcnt) > sndbuf_getmaxsize(ch->buffer)) {
+	while ((blksz * blkcnt) > ch->buffer->maxsize) {
 		if ((blkcnt >> 1) >= ES_DMA_SEGS_MIN)
 			blkcnt >>= 1;
 		else if ((blksz >> 1) >= ES_BLK_MIN)
@@ -655,15 +655,15 @@
 			break;
 	}
 
-	if ((sndbuf_getblksz(ch->buffer) != blksz ||
-	    sndbuf_getblkcnt(ch->buffer) != blkcnt) &&
+	if ((ch->buffer->blksz != blksz ||
+	    ch->buffer->blkcnt != blkcnt) &&
 	    sndbuf_resize(ch->buffer, blkcnt, blksz) != 0)
 		device_printf(es->dev, "%s: failed blksz=%u blkcnt=%u\n",
 		    __func__, blksz, blkcnt);
 
-	ch->bufsz = sndbuf_getsize(ch->buffer);
-	ch->blksz = sndbuf_getblksz(ch->buffer);
-	ch->blkcnt = sndbuf_getblkcnt(ch->buffer);
+	ch->bufsz = ch->buffer->bufsize;
+	ch->blksz = ch->buffer->blksz;
+	ch->blkcnt = ch->buffer->blkcnt;
 
 	return (0);
 }
@@ -762,7 +762,7 @@
 		return 0;
 
 	ES_LOCK(es);
-	cnt = (ch->blksz / sndbuf_getalign(ch->buffer)) - 1;
+	cnt = (ch->blksz / ch->buffer->align) - 1;
 	if (ch->fmt & AFMT_16BIT)
 		b |= 0x02;
 	if (AFMT_CHANNEL(ch->fmt) > 1)
diff --git a/sys/dev/sound/pci/fm801.c b/sys/dev/sound/pci/fm801.c
--- a/sys/dev/sound/pci/fm801.c
+++ b/sys/dev/sound/pci/fm801.c
@@ -440,7 +440,7 @@
 {
 	struct fm801_chinfo *ch = data;
 	struct fm801_info *fm801 = ch->parent;
-	u_int32_t baseaddr = sndbuf_getbufaddr(ch->buffer);
+	u_int32_t baseaddr = ch->buffer->buf_addr;
 	u_int32_t k1;
 
 	DPRINT("fm801ch_trigger go %d , ", go);
diff --git a/sys/dev/sound/pci/hda/hdaa.c b/sys/dev/sound/pci/hda/hdaa.c
--- a/sys/dev/sound/pci/hda/hdaa.c
+++ b/sys/dev/sound/pci/hda/hdaa.c
@@ -2081,10 +2081,10 @@
 {
 	struct hdaa_chan *ch = data;
 
-	blksz -= blksz % lcm(HDA_DMA_ALIGNMENT, sndbuf_getalign(ch->b));
+	blksz -= blksz % lcm(HDA_DMA_ALIGNMENT, ch->b->align);
 
-	if (blksz > (sndbuf_getmaxsize(ch->b) / HDA_BDL_MIN))
-		blksz = sndbuf_getmaxsize(ch->b) / HDA_BDL_MIN;
+	if (blksz > (ch->b->maxsize / HDA_BDL_MIN))
+		blksz = ch->b->maxsize / HDA_BDL_MIN;
 	if (blksz < HDA_BLK_MIN)
 		blksz = HDA_BLK_MIN;
 	if (blkcnt > HDA_BDL_MAX)
@@ -2092,7 +2092,7 @@
 	if (blkcnt < HDA_BDL_MIN)
 		blkcnt = HDA_BDL_MIN;
 
-	while ((blksz * blkcnt) > sndbuf_getmaxsize(ch->b)) {
+	while ((blksz * blkcnt) > ch->b->maxsize) {
 		if ((blkcnt >> 1) >= HDA_BDL_MIN)
 			blkcnt >>= 1;
 		else if ((blksz >> 1) >= HDA_BLK_MIN)
@@ -2101,14 +2101,14 @@
 			break;
 	}
 
-	if ((sndbuf_getblksz(ch->b) != blksz ||
-	    sndbuf_getblkcnt(ch->b) != blkcnt) &&
+	if ((ch->b->blksz != blksz ||
+	    ch->b->blkcnt != blkcnt) &&
 	    sndbuf_resize(ch->b, blkcnt, blksz) != 0)
 		device_printf(ch->devinfo->dev, "%s: failed blksz=%u blkcnt=%u\n",
 		    __func__, blksz, blkcnt);
 
-	ch->blksz = sndbuf_getblksz(ch->b);
-	ch->blkcnt = sndbuf_getblkcnt(ch->b);
+	ch->blksz = ch->b->blksz;
+	ch->blkcnt = ch->b->blkcnt;
 
 	return (0);
 }
@@ -2169,7 +2169,7 @@
 	    ch->dir == PCMDIR_PLAY ? 1 : 0, ch->sid);
 	HDAC_STREAM_START(device_get_parent(devinfo->dev), devinfo->dev,
 	    ch->dir == PCMDIR_PLAY ? 1 : 0, ch->sid,
-	    sndbuf_getbufaddr(ch->b), ch->blksz, ch->blkcnt);
+	    ch->b->buf_addr, ch->blksz, ch->blkcnt);
 	ch->flags |= HDAA_CHN_RUNNING;
 	return (0);
 }
diff --git a/sys/dev/sound/pci/hdsp-pcm.c b/sys/dev/sound/pci/hdsp-pcm.c
--- a/sys/dev/sound/pci/hdsp-pcm.c
+++ b/sys/dev/sound/pci/hdsp-pcm.c
@@ -971,7 +971,7 @@
 		hdsp_write_4(sc, HDSP_FREQ_REG, hdsp_freq_reg_value(sc->speed));
 end:
 
-	return (sndbuf_getblksz(ch->buffer));
+	return (ch->buffer->blksz);
 }
 
 static uint32_t hdsp_bkp_fmt[] = {
diff --git a/sys/dev/sound/pci/hdspe-pcm.c b/sys/dev/sound/pci/hdspe-pcm.c
--- a/sys/dev/sound/pci/hdspe-pcm.c
+++ b/sys/dev/sound/pci/hdspe-pcm.c
@@ -962,7 +962,7 @@
 	    (sc->period * 4));
 end:
 
-	return (sndbuf_getblksz(ch->buffer));
+	return (ch->buffer->blksz);
 }
 
 static uint32_t hdspe_bkp_fmt[] = {
diff --git a/sys/dev/sound/pci/ich.c b/sys/dev/sound/pci/ich.c
--- a/sys/dev/sound/pci/ich.c
+++ b/sys/dev/sound/pci/ich.c
@@ -301,15 +301,15 @@
 	uint32_t base;
 	int i;
 
-	base = sndbuf_getbufaddr(ch->buffer);
-	if ((ch->blksz * ch->blkcnt) > sndbuf_getmaxsize(ch->buffer))
-		ch->blksz = sndbuf_getmaxsize(ch->buffer) / ch->blkcnt;
-	if ((sndbuf_getblksz(ch->buffer) != ch->blksz ||
-	    sndbuf_getblkcnt(ch->buffer) != ch->blkcnt) &&
+	base = ch->buffer->buf_addr;
+	if ((ch->blksz * ch->blkcnt) > ch->buffer->maxsize)
+		ch->blksz = ch->buffer->maxsize / ch->blkcnt;
+	if ((ch->buffer->blksz != ch->blksz ||
+	    ch->buffer->blkcnt != ch->blkcnt) &&
 	    sndbuf_resize(ch->buffer, ch->blkcnt, ch->blksz) != 0)
 		device_printf(sc->dev, "%s: failed blksz=%u blkcnt=%u\n",
 		    __func__, ch->blksz, ch->blkcnt);
-	ch->blksz = sndbuf_getblksz(ch->buffer);
+	ch->blksz = ch->buffer->blksz;
 
 	for (i = 0; i < ICH_DTBL_LENGTH; i++) {
 		ch->dtbl[i].buffer = base + (ch->blksz * (i % ch->blkcnt));
@@ -491,7 +491,7 @@
 	);
 
 	if (sc->flags & ICH_HIGH_LATENCY)
-		blocksize = sndbuf_getmaxsize(ch->buffer) / ch->blkcnt;
+		blocksize = ch->buffer->maxsize / ch->blkcnt;
 
 	if (blocksize < ICH_MIN_BLKSZ)
 		blocksize = ICH_MIN_BLKSZ;
@@ -734,7 +734,7 @@
 	ch->blkcnt = 2;
 	sc->flags |= ICH_CALIBRATE_DONE;
 	ICH_UNLOCK(sc);
-	ichchan_setblocksize(0, ch, sndbuf_getmaxsize(ch->buffer) >> 1);
+	ichchan_setblocksize(0, ch, ch->buffer->maxsize >> 1);
 	ICH_LOCK(sc);
 	sc->flags &= ~ICH_CALIBRATE_DONE;
 
diff --git a/sys/dev/sound/pci/maestro3.c b/sys/dev/sound/pci/maestro3.c
--- a/sys/dev/sound/pci/maestro3.c
+++ b/sys/dev/sound/pci/maestro3.c
@@ -444,10 +444,10 @@
 		return (NULL);
 	}
 	M3_LOCK(sc);
-	ch->bufsize = sndbuf_getsize(ch->buffer);
+	ch->bufsize = ch->buffer->bufsize;
 
 	/* host dma buffer pointers */
-	bus_addr = sndbuf_getbufaddr(ch->buffer);
+	bus_addr = ch->buffer->buf_addr;
 	if (bus_addr & 3) {
 		device_printf(sc->dev, "m3_pchan_init unaligned bus_addr\n");
 		bus_addr = (bus_addr + 4) & ~3;
@@ -595,7 +595,7 @@
 	M3_DEBUG(CHANGE, ("m3_pchan_setblocksize(dac=%d, blocksize=%d)\n",
 			  ch->dac_idx, blocksize));
 
-	return (sndbuf_getblksz(ch->buffer));
+	return (ch->buffer->blksz);
 }
 
 static int
@@ -709,7 +709,7 @@
 	struct sc_info *sc = ch->parent;
 	u_int32_t hi, lo, bus_base, bus_crnt;
 
-	bus_base = sndbuf_getbufaddr(ch->buffer);
+	bus_base = ch->buffer->buf_addr;
 	hi = m3_rd_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_CURRENTH);
         lo = m3_rd_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_CURRENTL);
         bus_crnt = lo | (hi << 16);
@@ -823,10 +823,10 @@
 		return (NULL);
 	}
 	M3_LOCK(sc);
-	ch->bufsize = sndbuf_getsize(ch->buffer);
+	ch->bufsize = ch->buffer->bufsize;
 
 	/* host dma buffer pointers */
-	bus_addr = sndbuf_getbufaddr(ch->buffer);
+	bus_addr = ch->buffer->buf_addr;
 	if (bus_addr & 3) {
 		device_printf(sc->dev, "m3_rchan_init unaligned bus_addr\n");
 		bus_addr = (bus_addr + 4) & ~3;
@@ -968,7 +968,7 @@
 	M3_DEBUG(CHANGE, ("m3_rchan_setblocksize(adc=%d, blocksize=%d)\n",
 			  ch->adc_idx, blocksize));
 
-	return (sndbuf_getblksz(ch->buffer));
+	return (ch->buffer->blksz);
 }
 
 static int
@@ -1061,7 +1061,7 @@
 	struct sc_info *sc = ch->parent;
 	u_int32_t hi, lo, bus_base, bus_crnt;
 
-	bus_base = sndbuf_getbufaddr(ch->buffer);
+	bus_base = ch->buffer->buf_addr;
 	hi = m3_rd_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_CURRENTH);
         lo = m3_rd_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_CURRENTL);
         bus_crnt = lo | (hi << 16);
@@ -1162,7 +1162,7 @@
 			pch->ptr = m3_pchan_getptr_internal(pch);
 			delta = pch->bufsize + pch->ptr - pch->prevptr;
 			delta %= pch->bufsize;
-			if (delta < sndbuf_getblksz(pch->buffer))
+			if (delta < pch->buffer->blksz)
 				continue;
 			pch->prevptr = pch->ptr;
 			M3_UNLOCK(sc);
@@ -1176,7 +1176,7 @@
 			rch->ptr = m3_rchan_getptr_internal(rch);
 			delta = rch->bufsize + rch->ptr - rch->prevptr;
 			delta %= rch->bufsize;
-			if (delta < sndbuf_getblksz(rch->buffer))
+			if (delta < rch->buffer->blksz)
 				continue;
 			rch->prevptr = rch->ptr;
 			M3_UNLOCK(sc);
diff --git a/sys/dev/sound/pci/neomagic.c b/sys/dev/sound/pci/neomagic.c
--- a/sys/dev/sound/pci/neomagic.c
+++ b/sys/dev/sound/pci/neomagic.c
@@ -362,7 +362,7 @@
 	sndbuf_setup(ch->buffer, (u_int8_t *)rman_get_virtual(sc->buf) + chnbuf, NM_BUFFSIZE);
 	if (bootverbose)
 		device_printf(sc->dev, "%s buf %p\n", (dir == PCMDIR_PLAY)?
-			      "play" : "rec", sndbuf_getbuf(ch->buffer));
+			      "play" : "rec", ch->buffer->buf);
 	ch->parent = sc;
 	ch->channel = c;
 	ch->dir = dir;
diff --git a/sys/dev/sound/pci/solo.c b/sys/dev/sound/pci/solo.c
--- a/sys/dev/sound/pci/solo.c
+++ b/sys/dev/sound/pci/solo.c
@@ -584,7 +584,8 @@
 	ess_lock(sc);
 	switch (go) {
 	case PCMTRIG_START:
-		ess_dmasetup(sc, ch->hwch, sndbuf_getbufaddr(ch->buffer), sndbuf_getsize(ch->buffer), ch->dir);
+		ess_dmasetup(sc, ch->hwch, ch->buffer->buf_addr,
+		    ch->buffer->bufsize, ch->dir);
 		ess_dmatrigger(sc, ch->hwch, 1);
 		ess_start(ch);
 		break;
diff --git a/sys/dev/sound/pci/t4dwave.c b/sys/dev/sound/pci/t4dwave.c
--- a/sys/dev/sound/pci/t4dwave.c
+++ b/sys/dev/sound/pci/t4dwave.c
@@ -555,9 +555,9 @@
 		ch->fms = 0;
 		ch->ec = 0;
 		ch->alpha = 0;
-		ch->lba = sndbuf_getbufaddr(ch->buffer);
+		ch->lba = ch->buffer->buf_addr;
 		ch->cso = 0;
-		ch->eso = (sndbuf_getsize(ch->buffer) / sndbuf_getalign(ch->buffer)) - 1;
+		ch->eso = (ch->buffer->bufsize / ch->buffer->align) - 1;
 		ch->rvol = ch->cvol = 0x7f;
 		ch->gvsel = 0;
 		ch->pan = 0;
@@ -581,7 +581,7 @@
 	struct tr_chinfo *ch = data;
 
 	tr_rdch(ch);
-	return ch->cso * sndbuf_getalign(ch->buffer);
+	return ch->cso * ch->buffer->align;
 }
 
 static struct pcmchan_caps *
@@ -680,7 +680,7 @@
 		i = tr_rd(tr, TR_REG_DMAR11, 1) & 0x03;
 		tr_wr(tr, TR_REG_DMAR11, i | 0x54, 1);
 		/* set up base address */
-	   	tr_wr(tr, TR_REG_DMAR0, sndbuf_getbufaddr(ch->buffer), 4);
+		tr_wr(tr, TR_REG_DMAR0, ch->buffer->buf_addr, 4);
 		/* set up buffer size */
 		i = tr_rd(tr, TR_REG_DMAR4, 4) & ~0x00ffffff;
 		tr_wr(tr, TR_REG_DMAR4, i | (sndbuf_runsz(ch->buffer) - 1), 4);
@@ -703,7 +703,7 @@
 	struct tr_info *tr = ch->parent;
 
 	/* return current byte offset of channel */
-	return tr_rd(tr, TR_REG_DMAR0, 4) - sndbuf_getbufaddr(ch->buffer);
+	return tr_rd(tr, TR_REG_DMAR0, 4) - ch->buffer->buf_addr;
 }
 
 static struct pcmchan_caps *
diff --git a/sys/dev/sound/pci/via8233.c b/sys/dev/sound/pci/via8233.c
--- a/sys/dev/sound/pci/via8233.c
+++ b/sys/dev/sound/pci/via8233.c
@@ -385,7 +385,7 @@
 	uint32_t phys_addr, flag;
 	int i;
 
-	phys_addr = sndbuf_getbufaddr(ch->buffer);
+	phys_addr = ch->buffer->buf_addr;
 
 	for (i = 0; i < ch->blkcnt; i++) {
 		flag = (i == ch->blkcnt - 1) ? VIA_DMAOP_EOL : VIA_DMAOP_FLAG;
@@ -568,8 +568,8 @@
 
 	blksz &= VIA_BLK_ALIGN;
 
-	if (blksz > (sndbuf_getmaxsize(ch->buffer) / VIA_SEGS_MIN))
-		blksz = sndbuf_getmaxsize(ch->buffer) / VIA_SEGS_MIN;
+	if (blksz > (ch->buffer->maxsize / VIA_SEGS_MIN))
+		blksz = ch->buffer->maxsize / VIA_SEGS_MIN;
 	if (blksz < VIA_BLK_MIN)
 		blksz = VIA_BLK_MIN;
 	if (blkcnt > VIA_SEGS_MAX)
@@ -577,7 +577,7 @@
 	if (blkcnt < VIA_SEGS_MIN)
 		blkcnt = VIA_SEGS_MIN;
 
-	while ((blksz * blkcnt) > sndbuf_getmaxsize(ch->buffer)) {
+	while ((blksz * blkcnt) > ch->buffer->maxsize) {
 		if ((blkcnt >> 1) >= VIA_SEGS_MIN)
 			blkcnt >>= 1;
 		else if ((blksz >> 1) >= VIA_BLK_MIN)
@@ -586,14 +586,14 @@
 			break;
 	}
 
-	if ((sndbuf_getblksz(ch->buffer) != blksz ||
-	    sndbuf_getblkcnt(ch->buffer) != blkcnt) &&
+	if ((ch->buffer->blksz != blksz ||
+	    ch->buffer->blkcnt != blkcnt) &&
 	    sndbuf_resize(ch->buffer, blkcnt, blksz) != 0)
 		device_printf(via->dev, "%s: failed blksz=%u blkcnt=%u\n",
 		    __func__, blksz, blkcnt);
 
-	ch->blksz = sndbuf_getblksz(ch->buffer);
-	ch->blkcnt = sndbuf_getblkcnt(ch->buffer);
+	ch->blksz = ch->buffer->blksz;
+	ch->blkcnt = ch->buffer->blkcnt;
 
 	return (0);
 }
@@ -850,8 +850,7 @@
 		if (ch->channel == NULL || ch->active == 0)
 			continue;
 		pollticks = ((uint64_t)hz * ch->blksz) /
-		    ((uint64_t)sndbuf_getalign(ch->buffer) *
-		    sndbuf_getspd(ch->buffer));
+		    ((uint64_t)ch->buffer->align * ch->buffer->spd);
 		pollticks >>= 2;
 		if (pollticks > hz)
 			pollticks = hz;
@@ -866,8 +865,7 @@
 		if (ch->channel == NULL || ch->active == 0)
 			continue;
 		pollticks = ((uint64_t)hz * ch->blksz) /
-		    ((uint64_t)sndbuf_getalign(ch->buffer) *
-		    sndbuf_getspd(ch->buffer));
+		    ((uint64_t)ch->buffer->align * ch->buffer->spd);
 		pollticks >>= 2;
 		if (pollticks > hz)
 			pollticks = hz;
@@ -900,8 +898,8 @@
 			ch->ptr = 0;
 			ch->prevptr = 0;
 			pollticks = ((uint64_t)hz * ch->blksz) /
-			    ((uint64_t)sndbuf_getalign(ch->buffer) *
-			    sndbuf_getspd(ch->buffer));
+			    ((uint64_t)ch->buffer->align *
+			    ch->buffer->spd);
 			pollticks >>= 2;
 			if (pollticks > hz)
 				pollticks = hz;
diff --git a/sys/dev/sound/pci/via82c686.c b/sys/dev/sound/pci/via82c686.c
--- a/sys/dev/sound/pci/via82c686.c
+++ b/sys/dev/sound/pci/via82c686.c
@@ -226,8 +226,8 @@
 	 *  is feeding.
 	 */
 	seg_size = ch->blksz;
-	segs = sndbuf_getsize(ch->buffer) / seg_size;
-	phys_addr = sndbuf_getbufaddr(ch->buffer);
+	segs = ch->buffer->bufsize / seg_size;
+	phys_addr = ch->buffer->buf_addr;
 
 	for (i = 0; i < segs; i++) {
 		flag = (i == segs - 1)? VIA_DMAOP_EOL : VIA_DMAOP_FLAG;
@@ -385,7 +385,7 @@
 		seg = SEGS_PER_CHAN;
 
 	/* Now work out offset: seg less count */
-	ptr = (seg * sndbuf_getsize(ch->buffer) / SEGS_PER_CHAN) - len;
+	ptr = (seg * ch->buffer->bufsize / SEGS_PER_CHAN) - len;
 	if (ch->dir == PCMDIR_REC) {
 		/* DMA appears to operate on memory 'lines' of 32 bytes	*/
 		/* so don't return any part line - it isn't in RAM yet	*/
diff --git a/sys/dev/sound/pci/vibes.c b/sys/dev/sound/pci/vibes.c
--- a/sys/dev/sound/pci/vibes.c
+++ b/sys/dev/sound/pci/vibes.c
@@ -328,9 +328,9 @@
 		sv_indirect_set(sc, SV_REG_FORMAT, v);
 
 		/* Program DMA */
-		count = sndbuf_getsize(ch->buffer) / 2; /* DMAC uses words */
+		count = ch->buffer->bufsize / 2; /* DMAC uses words */
 		sv_dma_set_config(sc->dmac_st, sc->dmac_sh,
-				  sndbuf_getbufaddr(ch->buffer),
+				  ch->buffer->buf_addr,
 				  count - 1,
 				  SV_DMA_MODE_AUTO | SV_DMA_MODE_RD);
 		count = count / SV_INTR_PER_BUFFER - 1;
@@ -360,7 +360,7 @@
 	struct sc_info 		*sc = ch->parent;
 	u_int32_t sz, remain;
 
-	sz = sndbuf_getsize(ch->buffer);
+	sz = ch->buffer->bufsize;
 	/* DMAC uses words */
 	remain = (sv_dma_get_count(sc->dmac_st, sc->dmac_sh) + 1) * 2;
 	return sz - remain;
@@ -404,9 +404,9 @@
 		sv_indirect_set(sc, SV_REG_FORMAT, v);
 
 		/* Program DMA */
-		count = sndbuf_getsize(ch->buffer);
+		count = ch->buffer->bufsize;
 		sv_dma_set_config(sc->dmaa_st, sc->dmaa_sh,
-				  sndbuf_getbufaddr(ch->buffer),
+				  ch->buffer->buf_addr,
 				  count - 1,
 				  SV_DMA_MODE_AUTO | SV_DMA_MODE_WR);
 		count = count / SV_INTR_PER_BUFFER - 1;
@@ -437,7 +437,7 @@
 	struct sc_info 		*sc = ch->parent;
 	u_int32_t sz, remain;
 
-	sz = sndbuf_getsize(ch->buffer);
+	sz = ch->buffer->bufsize;
 	/* DMAA uses bytes */
 	remain = sv_dma_get_count(sc->dmaa_st, sc->dmaa_sh) + 1;
 	return (sz - remain);
diff --git a/sys/dev/sound/pcm/buffer.h b/sys/dev/sound/pcm/buffer.h
--- a/sys/dev/sound/pcm/buffer.h
+++ b/sys/dev/sound/pcm/buffer.h
@@ -73,43 +73,21 @@
 void sndbuf_softreset(struct snd_dbuf *b);
 void sndbuf_clearshadow(struct snd_dbuf *b);
 
-u_int32_t sndbuf_getfmt(struct snd_dbuf *b);
 int sndbuf_setfmt(struct snd_dbuf *b, u_int32_t fmt);
-unsigned int sndbuf_getspd(struct snd_dbuf *b);
 void sndbuf_setspd(struct snd_dbuf *b, unsigned int spd);
-unsigned int sndbuf_getbps(struct snd_dbuf *b);
 
-bus_addr_t sndbuf_getbufaddr(struct snd_dbuf *buf);
-
-void *sndbuf_getbuf(struct snd_dbuf *b);
 void *sndbuf_getbufofs(struct snd_dbuf *b, unsigned int ofs);
-unsigned int sndbuf_getsize(struct snd_dbuf *b);
-unsigned int sndbuf_getmaxsize(struct snd_dbuf *b);
-unsigned int sndbuf_getallocsize(struct snd_dbuf *b);
-unsigned int sndbuf_getalign(struct snd_dbuf *b);
-unsigned int sndbuf_getblkcnt(struct snd_dbuf *b);
-void sndbuf_setblkcnt(struct snd_dbuf *b, unsigned int blkcnt);
-unsigned int sndbuf_getblksz(struct snd_dbuf *b);
-void sndbuf_setblksz(struct snd_dbuf *b, unsigned int blksz);
 unsigned int sndbuf_runsz(struct snd_dbuf *b);
 void sndbuf_setrun(struct snd_dbuf *b, int go);
-struct selinfo *sndbuf_getsel(struct snd_dbuf *b);
 
-unsigned int sndbuf_getxrun(struct snd_dbuf *b);
 void sndbuf_setxrun(struct snd_dbuf *b, unsigned int xrun);
-unsigned int sndbuf_gethwptr(struct snd_dbuf *b);
-void sndbuf_sethwptr(struct snd_dbuf *b, unsigned int ptr);
 unsigned int sndbuf_getfree(struct snd_dbuf *b);
 unsigned int sndbuf_getfreeptr(struct snd_dbuf *b);
 unsigned int sndbuf_getready(struct snd_dbuf *b);
 unsigned int sndbuf_getreadyptr(struct snd_dbuf *b);
 u_int64_t sndbuf_getblocks(struct snd_dbuf *b);
-u_int64_t sndbuf_getprevblocks(struct snd_dbuf *b);
-u_int64_t sndbuf_gettotal(struct snd_dbuf *b);
-u_int64_t sndbuf_getprevtotal(struct snd_dbuf *b);
 unsigned int sndbuf_xbytes(unsigned int v, struct snd_dbuf *from, struct snd_dbuf *to);
 u_int8_t sndbuf_zerodata(u_int32_t fmt);
-void sndbuf_updateprevtotal(struct snd_dbuf *b);
 
 int sndbuf_acquire(struct snd_dbuf *b, u_int8_t *from, unsigned int count);
 int sndbuf_dispose(struct snd_dbuf *b, u_int8_t *to, unsigned int count);
diff --git a/sys/dev/sound/pcm/buffer.c b/sys/dev/sound/pcm/buffer.c
--- a/sys/dev/sound/pcm/buffer.c
+++ b/sys/dev/sound/pcm/buffer.c
@@ -63,12 +63,6 @@
 	free(b, M_DEVBUF);
 }
 
-bus_addr_t
-sndbuf_getbufaddr(struct snd_dbuf *buf)
-{
-	return (buf->buf_addr);
-}
-
 static void
 sndbuf_setmap(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 {
@@ -150,7 +144,7 @@
 		} else
 			free(b->buf, M_DEVBUF);
 	}
-	seldrain(sndbuf_getsel(b));
+	seldrain(&b->sel);
 
 	b->tmpbuf = NULL;
 	b->shadbuf = NULL;
@@ -281,7 +275,7 @@
 
 	data = sndbuf_zerodata(b->fmt);
 	i = sndbuf_getfreeptr(b);
-	p = sndbuf_getbuf(b);
+	p = b->buf;
 	while (length-- > 0)
 		p[i++ % b->bufsize] = data;
 }
@@ -295,7 +289,7 @@
 sndbuf_fillsilence(struct snd_dbuf *b)
 {
 	if (b->bufsize > 0)
-		memset(sndbuf_getbuf(b), sndbuf_zerodata(b->fmt), b->bufsize);
+		memset(b->buf, sndbuf_zerodata(b->fmt), b->bufsize);
 	b->rp = 0;
 	b->rl = b->bufsize;
 }
@@ -304,7 +298,7 @@
 sndbuf_fillsilence_rl(struct snd_dbuf *b, u_int rl)
 {
 	if (b->bufsize > 0)
-		memset(sndbuf_getbuf(b), sndbuf_zerodata(b->fmt), b->bufsize);
+		memset(b->buf, sndbuf_zerodata(b->fmt), b->bufsize);
 	b->rp = 0;
 	b->rl = min(b->bufsize, rl);
 }
@@ -341,12 +335,6 @@
 	sndbuf_clearshadow(b);
 }
 
-u_int32_t
-sndbuf_getfmt(struct snd_dbuf *b)
-{
-	return b->fmt;
-}
-
 int
 sndbuf_setfmt(struct snd_dbuf *b, u_int32_t fmt)
 {
@@ -356,60 +344,12 @@
 	return 0;
 }
 
-unsigned int
-sndbuf_getspd(struct snd_dbuf *b)
-{
-	return b->spd;
-}
-
 void
 sndbuf_setspd(struct snd_dbuf *b, unsigned int spd)
 {
 	b->spd = spd;
 }
 
-unsigned int
-sndbuf_getalign(struct snd_dbuf *b)
-{
-	return (b->align);
-}
-
-unsigned int
-sndbuf_getblkcnt(struct snd_dbuf *b)
-{
-	return b->blkcnt;
-}
-
-void
-sndbuf_setblkcnt(struct snd_dbuf *b, unsigned int blkcnt)
-{
-	b->blkcnt = blkcnt;
-}
-
-unsigned int
-sndbuf_getblksz(struct snd_dbuf *b)
-{
-	return b->blksz;
-}
-
-void
-sndbuf_setblksz(struct snd_dbuf *b, unsigned int blksz)
-{
-	b->blksz = blksz;
-}
-
-unsigned int
-sndbuf_getbps(struct snd_dbuf *b)
-{
-	return b->bps;
-}
-
-void *
-sndbuf_getbuf(struct snd_dbuf *b)
-{
-	return b->buf;
-}
-
 void *
 sndbuf_getbufofs(struct snd_dbuf *b, unsigned int ofs)
 {
@@ -418,24 +358,6 @@
 	return b->buf + ofs;
 }
 
-unsigned int
-sndbuf_getsize(struct snd_dbuf *b)
-{
-	return b->bufsize;
-}
-
-unsigned int
-sndbuf_getmaxsize(struct snd_dbuf *b)
-{
-	return b->maxsize;
-}
-
-unsigned int
-sndbuf_getallocsize(struct snd_dbuf *b)
-{
-	return b->allocsize;
-}
-
 unsigned int
 sndbuf_runsz(struct snd_dbuf *b)
 {
@@ -448,37 +370,12 @@
 	b->dl = go? b->blksz : 0;
 }
 
-struct selinfo *
-sndbuf_getsel(struct snd_dbuf *b)
-{
-	return &b->sel;
-}
-
-/************************************************************/
-unsigned int
-sndbuf_getxrun(struct snd_dbuf *b)
-{
-	return b->xrun;
-}
-
 void
 sndbuf_setxrun(struct snd_dbuf *b, unsigned int xrun)
 {
 	b->xrun = xrun;
 }
 
-unsigned int
-sndbuf_gethwptr(struct snd_dbuf *b)
-{
-	return b->hp;
-}
-
-void
-sndbuf_sethwptr(struct snd_dbuf *b, unsigned int ptr)
-{
-	b->hp = ptr;
-}
-
 unsigned int
 sndbuf_getready(struct snd_dbuf *b)
 {
@@ -518,38 +415,13 @@
 	return b->total / b->blksz;
 }
 
-u_int64_t
-sndbuf_getprevblocks(struct snd_dbuf *b)
-{
-	return b->prev_total / b->blksz;
-}
-
-u_int64_t
-sndbuf_gettotal(struct snd_dbuf *b)
-{
-	return b->total;
-}
-
-u_int64_t
-sndbuf_getprevtotal(struct snd_dbuf *b)
-{
-	return b->prev_total;
-}
-
-void
-sndbuf_updateprevtotal(struct snd_dbuf *b)
-{
-	b->prev_total = b->total;
-}
-
 unsigned int
 sndbuf_xbytes(unsigned int v, struct snd_dbuf *from, struct snd_dbuf *to)
 {
 	if (from == NULL || to == NULL || v == 0)
 		return 0;
 
-	return snd_xbytes(v, sndbuf_getalign(from) * sndbuf_getspd(from),
-	    sndbuf_getalign(to) * sndbuf_getspd(to));
+	return snd_xbytes(v, from->align * from->spd, to->align * to->spd);
 }
 
 u_int8_t
@@ -589,7 +461,7 @@
 	b->total += count;
 	if (from != NULL) {
 		while (count > 0) {
-			l = min(count, sndbuf_getsize(b) - sndbuf_getfreeptr(b));
+			l = min(count, b->bufsize - sndbuf_getfreeptr(b));
 			bcopy(from, sndbuf_getbufofs(b, sndbuf_getfreeptr(b)), l);
 			from += l;
 			b->rl += l;
@@ -625,7 +497,7 @@
 	KASSERT((b->rl >= 0) && (b->rl <= b->bufsize), ("%s: b->rl invalid %d", __func__, b->rl));
 	if (to != NULL) {
 		while (count > 0) {
-			l = min(count, sndbuf_getsize(b) - sndbuf_getreadyptr(b));
+			l = min(count, b->bufsize - sndbuf_getreadyptr(b));
 			bcopy(sndbuf_getbufofs(b, sndbuf_getreadyptr(b)), to, l);
 			to += l;
 			b->rl -= l;
@@ -670,7 +542,7 @@
 	if (sndbuf_getfree(to) < count)
 		return (EINVAL);
 
-	maxfeed = SND_FXROUND(SND_FXDIV_MAX, sndbuf_getalign(to));
+	maxfeed = SND_FXROUND(SND_FXDIV_MAX, to->align);
 
 	do {
 		cnt = FEEDER_FEED(feeder, channel, to->tmpbuf,
diff --git a/sys/dev/sound/pcm/channel.c b/sys/dev/sound/pcm/channel.c
--- a/sys/dev/sound/pcm/channel.c
+++ b/sys/dev/sound/pcm/channel.c
@@ -280,10 +280,10 @@
 	CHN_LOCKASSERT(c);
 
 	if (c->flags & CHN_F_MMAP) {
-		if (sndbuf_getprevtotal(bs) < c->lw)
+		if (bs->prev_total < c->lw)
 			delta = c->lw;
 		else
-			delta = sndbuf_gettotal(bs) - sndbuf_getprevtotal(bs);
+			delta = bs->total - bs->prev_total;
 	} else {
 		if (c->direction == PCMDIR_PLAY)
 			delta = sndbuf_getfree(bs);
@@ -299,7 +299,7 @@
 {
 
 	CHN_LOCKASSERT(c);
-	sndbuf_updateprevtotal(c->bufsoft);
+	c->bufsoft->prev_total = c->bufsoft->total;
 }
 
 static void
@@ -314,8 +314,8 @@
 
 	if (CHN_EMPTY(c, children.busy)) {
 		KNOTE_LOCKED(&bs->sel.si_note, 0);
-		if (SEL_WAITING(sndbuf_getsel(bs)) && chn_polltrigger(c))
-			selwakeuppri(sndbuf_getsel(bs), PRIBIO);
+		if (SEL_WAITING(&bs->sel) && chn_polltrigger(c))
+			selwakeuppri(&bs->sel, PRIBIO);
 		CHN_BROADCAST(&c->intr_cv);
 	} else {
 		CHN_FOREACH(ch, c, children.busy) {
@@ -354,22 +354,22 @@
 	struct snd_dbuf *b = c->bufhard;
 	unsigned int delta, old, hwptr, amt;
 
-	KASSERT(sndbuf_getsize(b) > 0, ("bufsize == 0"));
+	KASSERT(b->bufsize > 0, ("bufsize == 0"));
 	CHN_LOCKASSERT(c);
 
-	old = sndbuf_gethwptr(b);
+	old = b->hp;
 	hwptr = chn_getptr(c);
-	delta = (sndbuf_getsize(b) + hwptr - old) % sndbuf_getsize(b);
-	sndbuf_sethwptr(b, hwptr);
+	delta = (b->bufsize + hwptr - old) % b->bufsize;
+	b->hp = hwptr;
 
 	if (c->direction == PCMDIR_PLAY) {
 		amt = min(delta, sndbuf_getready(b));
-		amt -= amt % sndbuf_getalign(b);
+		amt -= amt % b->align;
 		if (amt > 0)
 			sndbuf_dispose(b, NULL, amt);
 	} else {
 		amt = min(delta, sndbuf_getfree(b));
-		amt -= amt % sndbuf_getalign(b);
+		amt -= amt % b->align;
 		if (amt > 0)
 		       sndbuf_acquire(b, NULL, amt);
 	}
@@ -397,8 +397,7 @@
 		sndbuf_acquire(bs, NULL, sndbuf_getfree(bs));
 
 	wasfree = sndbuf_getfree(b);
-	want = min(sndbuf_getsize(b),
-	    imax(0, sndbuf_xbytes(sndbuf_getsize(bs), bs, b) -
+	want = min(b->bufsize, imax(0, sndbuf_xbytes(bs->bufsize, bs, b) -
 	     sndbuf_getready(b)));
 	amt = min(wasfree, want);
 	if (amt > 0)
@@ -456,7 +455,7 @@
 			 */
 			while (ret == 0 && sz > 0) {
 				p = sndbuf_getfreeptr(bs);
-				t = min(sz, sndbuf_getsize(bs) - p);
+				t = min(sz, bs->bufsize - p);
 				off = sndbuf_getbufofs(bs, p);
 				CHN_UNLOCK(c);
 				ret = uiomove(off, t, buf);
@@ -578,7 +577,7 @@
 			 */
 			while (ret == 0 && sz > 0) {
 				p = sndbuf_getreadyptr(bs);
-				t = min(sz, sndbuf_getsize(bs) - p);
+				t = min(sz, bs->bufsize - p);
 				off = sndbuf_getbufofs(bs, p);
 				CHN_UNLOCK(c);
 				ret = uiomove(off, t, buf);
@@ -664,7 +663,7 @@
 
 				pb = CHN_BUF_PARENT(c, b);
 				i = sndbuf_xbytes(sndbuf_getready(bs), bs, pb);
-				j = sndbuf_getalign(pb);
+				j = pb->align;
 			}
 		}
 		if (snd_verbose > 3 && CHN_EMPTY(c, children))
@@ -687,7 +686,7 @@
 		if (c->parentchannel == NULL) {
 			if (c->direction == PCMDIR_PLAY)
 				sndbuf_fillsilence_rl(b,
-				    sndbuf_xbytes(sndbuf_getsize(bs), bs, b));
+				    sndbuf_xbytes(bs->bufsize, bs, b));
 			if (snd_verbose > 3)
 				device_printf(c->dev,
 				    "%s(): %s starting! (%s/%s) "
@@ -700,8 +699,8 @@
 				    "running",
 				    sndbuf_getready(b),
 				    force, i, j, c->timeout,
-				    (sndbuf_getsize(b) * 1000) /
-				    (sndbuf_getalign(b) * sndbuf_getspd(b)));
+				    (b->bufsize * 1000) /
+				    (b->align * b->spd));
 		}
 		err = chn_trigger(c, PCMTRIG_START);
 	}
@@ -760,7 +759,7 @@
 	syncdelay = chn_syncdelay;
 
 	if (syncdelay < 0 && (threshold > 0 || sndbuf_getready(bs) > 0))
-		minflush += sndbuf_xbytes(sndbuf_getsize(b), b, bs);
+		minflush += sndbuf_xbytes(b->bufsize, b, bs);
 
 	/*
 	 * Append (0-1000) millisecond trailing buffer (if needed)
@@ -768,10 +767,10 @@
 	 * to avoid audible truncation.
 	 */
 	if (syncdelay > 0)
-		minflush += (sndbuf_getalign(bs) * sndbuf_getspd(bs) *
+		minflush += (bs->align * bs->spd *
 		    ((syncdelay > 1000) ? 1000 : syncdelay)) / 1000;
 
-	minflush -= minflush % sndbuf_getalign(bs);
+	minflush -= minflush % bs->align;
 
 	if (minflush > 0) {
 		threshold = min(minflush, sndbuf_getfree(bs));
@@ -782,14 +781,14 @@
 
 	resid = sndbuf_getready(bs);
 	residp = resid;
-	blksz = sndbuf_getblksz(b);
+	blksz = b->blksz;
 	if (blksz < 1) {
 		device_printf(c->dev,
 		    "%s(): WARNING: blksz < 1 ! maxsize=%d [%d/%d/%d]\n",
-		    __func__, sndbuf_getmaxsize(b), sndbuf_getsize(b),
-		    sndbuf_getblksz(b), sndbuf_getblkcnt(b));
-		if (sndbuf_getblkcnt(b) > 0)
-			blksz = sndbuf_getsize(b) / sndbuf_getblkcnt(b);
+		    __func__, b->maxsize, b->bufsize,
+		    b->blksz, b->blkcnt);
+		if (b->blkcnt > 0)
+			blksz = b->bufsize / b->blkcnt;
 		if (blksz < 1)
 			blksz = 1;
 	}
@@ -875,7 +874,7 @@
 		chn_pollreset(c);
 		ret = ev;
 	} else
-		selrecord(td, sndbuf_getsel(bs));
+		selrecord(td, &bs->sel);
 
 	return (ret);
 }
@@ -1286,7 +1285,7 @@
 		goto fail;
 	}
 
-	if ((sndbuf_getsize(b) == 0) && ((c->flags & CHN_F_VIRTUAL) == 0)) {
+	if (b->bufsize == 0 && ((c->flags & CHN_F_VIRTUAL) == 0)) {
 		device_printf(d->dev, "%s(): hardware buffer's size is 0\n",
 		    __func__);
 		goto fail;
@@ -1304,7 +1303,7 @@
 	 * 	 seems to only come into existence in sndbuf_resize().
 	 */
 	if (c->direction == PCMDIR_PLAY) {
-		bs->sl = sndbuf_getmaxsize(bs);
+		bs->sl = bs->maxsize;
 		bs->shadbuf = malloc(bs->sl, M_DEVBUF, M_WAITOK);
 	}
 
@@ -1321,8 +1320,8 @@
 	if ((c->flags & CHN_F_VIRTUAL) == 0) {
 		CHN_INSERT_SORT_ASCEND(d, c, channels.pcm.primary);
 		/* Initialize the *vchanrate/vchanformat parameters. */
-		*vchanrate = sndbuf_getspd(c->bufsoft);
-		*vchanformat = sndbuf_getfmt(c->bufsoft);
+		*vchanrate = c->bufsoft->spd;
+		*vchanformat = c->bufsoft->fmt;
 	}
 
 	return (c);
@@ -1900,20 +1899,20 @@
 	b = c->bufhard;
 
 	if (!(blksz == 0 || blkcnt == -1) &&
-	    (blksz < 16 || blksz < sndbuf_getalign(bs) || blkcnt < 2 ||
+	    (blksz < 16 || blksz < bs->align || blkcnt < 2 ||
 	    (blksz * blkcnt) > CHN_2NDBUFMAXSIZE))
 		return EINVAL;
 
-	chn_calclatency(c->direction, latency, sndbuf_getalign(bs),
-	    sndbuf_getalign(bs) * sndbuf_getspd(bs), CHN_2NDBUFMAXSIZE,
+	chn_calclatency(c->direction, latency, bs->align,
+	    bs->align * bs->spd, CHN_2NDBUFMAXSIZE,
 	    &sblksz, &sblkcnt);
 
 	if (blksz == 0 || blkcnt == -1) {
 		if (blkcnt == -1)
 			c->flags &= ~CHN_F_HAS_SIZE;
 		if (c->flags & CHN_F_HAS_SIZE) {
-			blksz = sndbuf_getblksz(bs);
-			blkcnt = sndbuf_getblkcnt(bs);
+			blksz = bs->blksz;
+			blkcnt = bs->blkcnt;
 		}
 	} else
 		c->flags |= CHN_F_HAS_SIZE;
@@ -1926,7 +1925,7 @@
 		 * defeat the purpose of having custom control. The least
 		 * we can do is round it to the nearest ^2 and align it.
 		 */
-		sblksz = round_blksz(blksz, sndbuf_getalign(bs));
+		sblksz = round_blksz(blksz, bs->align);
 		sblkcnt = round_pow2(blkcnt);
 	}
 
@@ -1939,49 +1938,46 @@
 		CHN_LOCK(c);
 		if (c->direction == PCMDIR_PLAY) {
 			limit = (pb != NULL) ?
-			    sndbuf_xbytes(sndbuf_getsize(pb), pb, bs) : 0;
+			    sndbuf_xbytes(pb->bufsize, pb, bs) : 0;
 		} else {
 			limit = (pb != NULL) ?
-			    sndbuf_xbytes(sndbuf_getblksz(pb), pb, bs) * 2 : 0;
+			    sndbuf_xbytes(pb->blksz, pb, bs) * 2 : 0;
 		}
 	} else {
 		hblkcnt = 2;
 		if (c->flags & CHN_F_HAS_SIZE) {
 			hblksz = round_blksz(sndbuf_xbytes(sblksz, bs, b),
-			    sndbuf_getalign(b));
-			hblkcnt = round_pow2(sndbuf_getblkcnt(bs));
+			    b->align);
+			hblkcnt = round_pow2(bs->blkcnt);
 		} else
 			chn_calclatency(c->direction, latency,
-			    sndbuf_getalign(b),
-			    sndbuf_getalign(b) * sndbuf_getspd(b),
+			    b->align, b->align * b->spd,
 			    CHN_2NDBUFMAXSIZE, &hblksz, &hblkcnt);
 
-		if ((hblksz << 1) > sndbuf_getmaxsize(b))
-			hblksz = round_blksz(sndbuf_getmaxsize(b) >> 1,
-			    sndbuf_getalign(b));
+		if ((hblksz << 1) > b->maxsize)
+			hblksz = round_blksz(b->maxsize >> 1, b->align);
 
-		while ((hblksz * hblkcnt) > sndbuf_getmaxsize(b)) {
+		while ((hblksz * hblkcnt) > b->maxsize) {
 			if (hblkcnt < 4)
 				hblksz >>= 1;
 			else
 				hblkcnt >>= 1;
 		}
 
-		hblksz -= hblksz % sndbuf_getalign(b);
+		hblksz -= hblksz % b->align;
 
 		CHN_UNLOCK(c);
 		if (chn_usefrags == 0 ||
 		    CHANNEL_SETFRAGMENTS(c->methods, c->devinfo,
 		    hblksz, hblkcnt) != 0)
-			sndbuf_setblksz(b, CHANNEL_SETBLOCKSIZE(c->methods,
-			    c->devinfo, hblksz));
+			b->blksz = CHANNEL_SETBLOCKSIZE(c->methods,
+			    c->devinfo, hblksz);
 		CHN_LOCK(c);
 
 		if (!CHN_EMPTY(c, children)) {
 			nsblksz = round_blksz(
-			    sndbuf_xbytes(sndbuf_getblksz(b), b, bs),
-			    sndbuf_getalign(bs));
-			nsblkcnt = sndbuf_getblkcnt(b);
+			    sndbuf_xbytes(b->blksz, b, bs), bs->align);
+			nsblkcnt = b->blkcnt;
 			if (c->direction == PCMDIR_PLAY) {
 				do {
 					nsblkcnt--;
@@ -1993,7 +1989,7 @@
 			sblkcnt = nsblkcnt;
 			limit = 0;
 		} else
-			limit = sndbuf_xbytes(sndbuf_getblksz(b), b, bs) * 2;
+			limit = sndbuf_xbytes(b->blksz, b, bs) * 2;
 	}
 
 	if (limit > CHN_2NDBUFMAXSIZE)
@@ -2009,10 +2005,10 @@
 			sblkcnt >>= 1;
 	}
 
-	sblksz -= sblksz % sndbuf_getalign(bs);
+	sblksz -= sblksz % bs->align;
 
-	if (sndbuf_getblkcnt(bs) != sblkcnt || sndbuf_getblksz(bs) != sblksz ||
-	    sndbuf_getsize(bs) != (sblkcnt * sblksz)) {
+	if (bs->blkcnt != sblkcnt || bs->blksz != sblksz ||
+	    bs->bufsize != (sblkcnt * sblksz)) {
 		ret = sndbuf_remalloc(bs, sblkcnt, sblksz);
 		if (ret != 0) {
 			device_printf(c->dev, "%s(): Failed: %d %d\n",
@@ -2024,8 +2020,8 @@
 	/*
 	 * Interrupt timeout
 	 */
-	c->timeout = ((u_int64_t)hz * sndbuf_getsize(bs)) /
-	    ((u_int64_t)sndbuf_getspd(bs) * sndbuf_getalign(bs));
+	c->timeout = ((u_int64_t)hz * bs->bufsize) /
+	    ((u_int64_t)bs->spd * bs->align);
 	if (c->parentchannel != NULL)
 		c->timeout = min(c->timeout, c->parentchannel->timeout);
 	if (c->timeout < 1)
@@ -2035,7 +2031,7 @@
 	 * OSSv4 docs: "By default OSS will set the low water level equal
 	 * to the fragment size which is optimal in most cases."
 	 */
-	c->lw = sndbuf_getblksz(bs);
+	c->lw = bs->blksz;
 	chn_resetbuf(c);
 
 	if (snd_verbose > 3)
@@ -2044,10 +2040,10 @@
 		    __func__, CHN_DIRSTR(c),
 		    (c->flags & CHN_F_VIRTUAL) ? "virtual" : "hardware",
 		    c->timeout,
-		    sndbuf_getsize(b), sndbuf_getblksz(b),
-		    sndbuf_getblkcnt(b),
-		    sndbuf_getsize(bs), sndbuf_getblksz(bs),
-		    sndbuf_getblkcnt(bs), limit);
+		    b->bufsize, b->blksz,
+		    b->blkcnt,
+		    bs->bufsize, bs->blksz,
+		    bs->blkcnt, limit);
 
 	return 0;
 }
@@ -2090,7 +2086,7 @@
 
 	sndbuf_setspd(c->bufhard, CHANNEL_SETSPEED(c->methods, c->devinfo,
 	    hwspeed));
-	hwspeed = sndbuf_getspd(c->bufhard);
+	hwspeed = c->bufhard->spd;
 
 	delta = (hwspeed > speed) ? (hwspeed - speed) : (speed - hwspeed);
 
@@ -2100,8 +2096,7 @@
 	ret = feeder_chain(c);
 
 	if (ret == 0)
-		ret = CHANNEL_SETFORMAT(c->methods, c->devinfo,
-		    sndbuf_getfmt(c->bufhard));
+		ret = CHANNEL_SETFORMAT(c->methods, c->devinfo, c->bufhard->fmt);
 
 	if (ret == 0)
 		ret = chn_resizebuf(c, -2, 0, 0);
@@ -2344,7 +2339,7 @@
 
 	CHN_LOCKASSERT(c);
 	hwptr = (CHN_STARTED(c)) ? CHANNEL_GETPTR(c->methods, c->devinfo) : 0;
-	return (hwptr - (hwptr % sndbuf_getalign(c->bufhard)));
+	return (hwptr - (hwptr % c->bufhard->align));
 }
 
 struct pcmchan_caps *
diff --git a/sys/dev/sound/pcm/dsp.c b/sys/dev/sound/pcm/dsp.c
--- a/sys/dev/sound/pcm/dsp.c
+++ b/sys/dev/sound/pcm/dsp.c
@@ -837,13 +837,13 @@
 	    		if (wrch) {
 				CHN_LOCK(wrch);
 				chn_setblocksize(wrch, 2, p->play_size);
-				p->play_size = sndbuf_getblksz(wrch->bufsoft);
+				p->play_size = wrch->bufsoft->blksz;
 				CHN_UNLOCK(wrch);
 			}
 	    		if (rdch) {
 				CHN_LOCK(rdch);
 				chn_setblocksize(rdch, 2, p->rec_size);
-				p->rec_size = sndbuf_getblksz(rdch->bufsoft);
+				p->rec_size = rdch->bufsoft->blksz;
 				CHN_UNLOCK(rdch);
 			}
 			PCM_RELEASE_QUICK(d);
@@ -855,12 +855,12 @@
 
 	    		if (wrch) {
 				CHN_LOCK(wrch);
-				p->play_size = sndbuf_getblksz(wrch->bufsoft);
+				p->play_size = wrch->bufsoft->blksz;
 				CHN_UNLOCK(wrch);
 			}
 	    		if (rdch) {
 				CHN_LOCK(rdch);
-				p->rec_size = sndbuf_getblksz(rdch->bufsoft);
+				p->rec_size = rdch->bufsoft->blksz;
 				CHN_UNLOCK(rdch);
 			}
 		}
@@ -975,8 +975,8 @@
 	                      		  pcaps? pcaps->minspeed : 0);
 	    		p->rate_max = min(rcaps? rcaps->maxspeed : 1000000,
 	                      		  pcaps? pcaps->maxspeed : 1000000);
-	    		p->bufsize = min(rdch? sndbuf_getsize(rdch->bufsoft) : 1000000,
-	                     		 wrch? sndbuf_getsize(wrch->bufsoft) : 1000000);
+			p->bufsize = min(rdch? rdch->bufsoft->bufsize : 1000000,
+					 wrch? wrch->bufsoft->bufsize : 1000000);
 			/* XXX bad on sb16 */
 	    		p->formats = (rdch? chn_getformats(rdch) : 0xffffffff) &
 			 	     (wrch? chn_getformats(wrch) : 0xffffffff);
@@ -1079,7 +1079,7 @@
 		chn = wrch ? wrch : rdch;
 		if (chn) {
 			CHN_LOCK(chn);
-			*arg_i = sndbuf_getblksz(chn->bufsoft);
+			*arg_i = chn->bufsoft->blksz;
 			CHN_UNLOCK(chn);
 		} else {
 			*arg_i = 0;
@@ -1317,8 +1317,8 @@
 		    	if (rdch) {
 				CHN_LOCK(rdch);
 				ret = chn_setblocksize(rdch, maxfrags, fragsz);
-				r_maxfrags = sndbuf_getblkcnt(rdch->bufsoft);
-				r_fragsz = sndbuf_getblksz(rdch->bufsoft);
+				r_maxfrags = rdch->bufsoft->blkcnt;
+				r_fragsz = rdch->bufsoft->blksz;
 				CHN_UNLOCK(rdch);
 			} else {
 				r_maxfrags = maxfrags;
@@ -1327,8 +1327,8 @@
 		    	if (wrch && ret == 0) {
 				CHN_LOCK(wrch);
 				ret = chn_setblocksize(wrch, maxfrags, fragsz);
- 				maxfrags = sndbuf_getblkcnt(wrch->bufsoft);
-				fragsz = sndbuf_getblksz(wrch->bufsoft);
+				maxfrags = wrch->bufsoft->blkcnt;
+				fragsz = wrch->bufsoft->blksz;
 				CHN_UNLOCK(wrch);
 			} else { /* use whatever came from the read channel */
 				maxfrags = r_maxfrags;
@@ -1354,9 +1354,9 @@
 
 				CHN_LOCK(rdch);
 				a->bytes = sndbuf_getready(bs);
-	        		a->fragments = a->bytes / sndbuf_getblksz(bs);
-	        		a->fragstotal = sndbuf_getblkcnt(bs);
-	        		a->fragsize = sndbuf_getblksz(bs);
+				a->fragments = a->bytes / bs->blksz;
+				a->fragstotal = bs->blkcnt;
+				a->fragsize = bs->blksz;
 				CHN_UNLOCK(rdch);
 	    		} else
 				ret = EINVAL;
@@ -1372,9 +1372,9 @@
 
 				CHN_LOCK(wrch);
 				a->bytes = sndbuf_getfree(bs);
-	        		a->fragments = a->bytes / sndbuf_getblksz(bs);
-	        		a->fragstotal = sndbuf_getblkcnt(bs);
-	        		a->fragsize = sndbuf_getblksz(bs);
+				a->fragments = a->bytes / bs->blksz;
+				a->fragstotal = bs->blkcnt;
+				a->fragsize = bs->blksz;
 				CHN_UNLOCK(wrch);
 	    		} else
 				ret = EINVAL;
@@ -1388,7 +1388,7 @@
 	        		struct snd_dbuf *bs = rdch->bufsoft;
 
 				CHN_LOCK(rdch);
-	        		a->bytes = sndbuf_gettotal(bs);
+				a->bytes = bs->total;
 	        		a->blocks = sndbuf_getblocks(bs) - rdch->blocks;
 	        		a->ptr = sndbuf_getfreeptr(bs);
 				rdch->blocks = sndbuf_getblocks(bs);
@@ -1405,7 +1405,7 @@
 	        		struct snd_dbuf *bs = wrch->bufsoft;
 
 				CHN_LOCK(wrch);
-	        		a->bytes = sndbuf_gettotal(bs);
+				a->bytes = bs->total;
 	        		a->blocks = sndbuf_getblocks(bs) - wrch->blocks;
 	        		a->ptr = sndbuf_getreadyptr(bs);
 				wrch->blocks = sndbuf_getblocks(bs);
@@ -1692,8 +1692,8 @@
 
 			CHN_LOCK(chn);
 			bs = chn->bufsoft;
-			oc->samples = sndbuf_gettotal(bs) / sndbuf_getalign(bs);
-			oc->fifo_samples = sndbuf_getready(bs) / sndbuf_getalign(bs);
+			oc->samples = bs->total / bs->align;
+			oc->fifo_samples = sndbuf_getready(bs) / bs->align;
 			CHN_UNLOCK(chn);
 		}
 		break;
@@ -1994,7 +1994,7 @@
 
 	c = ((nprot & PROT_WRITE) != 0) ? wrch : rdch;
 	if (c == NULL || (c->flags & CHN_F_MMAP_INVALID) ||
-	    (*offset  + size) > sndbuf_getallocsize(c->bufsoft) ||
+	    (*offset  + size) > c->bufsoft->allocsize ||
 	    (wrch != NULL && (wrch->flags & CHN_F_MMAP_INVALID)) ||
 	    (rdch != NULL && (rdch->flags & CHN_F_MMAP_INVALID))) {
 		dsp_unlock_chans(priv, FREAD | FWRITE);
diff --git a/sys/dev/sound/pcm/feeder.c b/sys/dev/sound/pcm/feeder.c
--- a/sys/dev/sound/pcm/feeder.c
+++ b/sys/dev/sound/pcm/feeder.c
@@ -433,9 +433,7 @@
 			    offset, count, l, ch->feedcount);
 
 		if (ch->feedcount == 1) {
-			memset(buffer,
-			    sndbuf_zerodata(sndbuf_getfmt(src)),
-			    offset);
+			memset(buffer, sndbuf_zerodata(src->fmt), offset);
 			if (l > 0)
 				sndbuf_dispose(src, buffer + offset, l);
 			else
@@ -443,9 +441,7 @@
 		} else {
 			if (l > 0)
 				sndbuf_dispose(src, buffer, l);
-			memset(buffer + l,
-			    sndbuf_zerodata(sndbuf_getfmt(src)),
-			    offset);
+			memset(buffer + l, sndbuf_zerodata(src->fmt), offset);
 			if (!(ch->flags & CHN_F_CLOSING))
 				ch->xruns++;
 		}
diff --git a/sys/dev/sound/pcm/feeder_chain.c b/sys/dev/sound/pcm/feeder_chain.c
--- a/sys/dev/sound/pcm/feeder_chain.c
+++ b/sys/dev/sound/pcm/feeder_chain.c
@@ -695,11 +695,11 @@
 		cdesc.origin.rate    = c->speed;
 		cdesc.target.afmt    = hwfmt;
 		cdesc.target.matrix  = hwmatrix;
-		cdesc.target.rate    = sndbuf_getspd(c->bufhard);
+		cdesc.target.rate    = c->bufhard->spd;
 	} else {
 		cdesc.origin.afmt    = hwfmt;
 		cdesc.origin.matrix  = hwmatrix;
-		cdesc.origin.rate    = sndbuf_getspd(c->bufhard);
+		cdesc.origin.rate    = c->bufhard->spd;
 		cdesc.target.afmt    = softfmt;
 		cdesc.target.matrix  = softmatrix;
 		cdesc.target.rate    = c->speed;
diff --git a/sys/dev/sound/pcm/feeder_mixer.c b/sys/dev/sound/pcm/feeder_mixer.c
--- a/sys/dev/sound/pcm/feeder_mixer.c
+++ b/sys/dev/sound/pcm/feeder_mixer.c
@@ -145,8 +145,8 @@
 	b = c->bufsoft;
 	b->rp = 0;
 	b->rl = 0;
-	cnt = sndbuf_getsize(b);
-	maxfeed = SND_FXROUND(SND_FXDIV_MAX, sndbuf_getalign(b));
+	cnt = b->bufsize;
+	maxfeed = SND_FXROUND(SND_FXDIV_MAX, b->align);
 
 	do {
 		cnt = FEEDER_FEED(c->feeder->source, c, b->tmpbuf,
@@ -158,7 +158,7 @@
 	} while (cnt != 0);
 
 	/* Not enough data */
-	if (b->rl < sndbuf_getalign(b)) {
+	if (b->rl < b->align) {
 		b->rl = 0;
 		return (0);
 	}
@@ -187,11 +187,11 @@
 		if (ch->flags & CHN_F_MMAP)
 			sndbuf_dispose(bs, NULL, sndbuf_getready(bs));
 		cnt = sndbuf_getfree(bs);
-		if (cnt < sndbuf_getalign(bs)) {
+		if (cnt < bs->align) {
 			CHN_UNLOCK(ch);
 			continue;
 		}
-		maxfeed = SND_FXROUND(SND_FXDIV_MAX, sndbuf_getalign(bs));
+		maxfeed = SND_FXROUND(SND_FXDIV_MAX, bs->align);
 		do {
 			cnt = FEEDER_FEED(ch->feeder, ch, bs->tmpbuf,
 			    min(cnt, maxfeed), b);
@@ -244,7 +244,7 @@
 	if (c->direction == PCMDIR_REC)
 		return (feed_mixer_rec(c));
 
-	sz = sndbuf_getsize(src);
+	sz = src->bufsize;
 	if (sz < count)
 		count = sz;
 
@@ -260,7 +260,7 @@
 	 * list of children and calling mixer function to mix count bytes from
 	 * each into our destination buffer, b.
 	 */
-	tmp = sndbuf_getbuf(src);
+	tmp = src->buf;
 	rcnt = 0;
 	mcnt = 0;
 	passthrough = 0;	/* 'passthrough' / 'exclusive' marker */
diff --git a/sys/dev/sound/pcm/sndstat.c b/sys/dev/sound/pcm/sndstat.c
--- a/sys/dev/sound/pcm/sndstat.c
+++ b/sys/dev/sound/pcm/sndstat.c
@@ -491,29 +491,29 @@
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_RIGHTVOL,
 		    CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FR));
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_FORMAT,
-		    sndbuf_getfmt(c->bufhard));
+		    c->bufhard->fmt);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_RATE,
-		    sndbuf_getspd(c->bufhard));
+		    c->bufhard->spd);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_SIZE,
-		    sndbuf_getsize(c->bufhard));
+		    c->bufhard->bufsize);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_BLKSZ,
-		    sndbuf_getblksz(c->bufhard));
+		    c->bufhard->blksz);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_BLKCNT,
-		    sndbuf_getblkcnt(c->bufhard));
+		    c->bufhard->blkcnt);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_FREE,
 		    sndbuf_getfree(c->bufhard));
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_READY,
 		    sndbuf_getready(c->bufhard));
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_FORMAT,
-		    sndbuf_getfmt(c->bufsoft));
+		    c->bufsoft->fmt);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_RATE,
-		    sndbuf_getspd(c->bufsoft));
+		    c->bufsoft->spd);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_SIZE,
-		    sndbuf_getsize(c->bufsoft));
+		    c->bufsoft->bufsize);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_BLKSZ,
-		    sndbuf_getblksz(c->bufsoft));
+		    c->bufsoft->blksz);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_BLKCNT,
-		    sndbuf_getblkcnt(c->bufsoft));
+		    c->bufsoft->blkcnt);
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_FREE,
 		    sndbuf_getfree(c->bufsoft));
 		nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_READY,
@@ -1267,14 +1267,11 @@
 		    (c->parentchannel != NULL) ?
 		    c->parentchannel->name : "", c->name);
 		sbuf_printf(s, "spd %d", c->speed);
-		if (c->speed != sndbuf_getspd(c->bufhard)) {
-			sbuf_printf(s, "/%d",
-			    sndbuf_getspd(c->bufhard));
-		}
+		if (c->speed != c->bufhard->spd)
+			sbuf_printf(s, "/%d", c->bufhard->spd);
 		sbuf_printf(s, ", fmt 0x%08x", c->format);
-		if (c->format != sndbuf_getfmt(c->bufhard)) {
-			sbuf_printf(s, "/0x%08x",
-			    sndbuf_getfmt(c->bufhard));
+		if (c->format != c->bufhard->fmt) {
+			sbuf_printf(s, "/0x%08x", c->bufhard->fmt);
 		}
 		sbuf_printf(s, ", flags 0x%08x, 0x%08x",
 		    c->flags, c->feederflags);
@@ -1293,24 +1290,24 @@
 				c->xruns, c->feedcount,
 				sndbuf_getfree(c->bufhard),
 				sndbuf_getfree(c->bufsoft),
-				sndbuf_getsize(c->bufhard),
-				sndbuf_getblksz(c->bufhard),
-				sndbuf_getblkcnt(c->bufhard),
-				sndbuf_getsize(c->bufsoft),
-				sndbuf_getblksz(c->bufsoft),
-				sndbuf_getblkcnt(c->bufsoft));
+				c->bufhard->bufsize,
+				c->bufhard->blksz,
+				c->bufhard->blkcnt,
+				c->bufsoft->bufsize,
+				c->bufsoft->blksz,
+				c->bufsoft->blkcnt);
 		} else {
 			sbuf_printf(s,
 			    "underruns %d, feed %u, ready %d "
 			    "\n\t\t[b:%d/%d/%d|bs:%d/%d/%d]",
 				c->xruns, c->feedcount,
 				sndbuf_getready(c->bufsoft),
-				sndbuf_getsize(c->bufhard),
-				sndbuf_getblksz(c->bufhard),
-				sndbuf_getblkcnt(c->bufhard),
-				sndbuf_getsize(c->bufsoft),
-				sndbuf_getblksz(c->bufsoft),
-				sndbuf_getblkcnt(c->bufsoft));
+				c->bufhard->bufsize,
+				c->bufhard->blksz,
+				c->bufhard->blkcnt,
+				c->bufsoft->bufsize,
+				c->bufsoft->blksz,
+				c->bufsoft->blkcnt);
 		}
 		sbuf_printf(s, "\n\t");
 
diff --git a/sys/dev/sound/pcm/vchan.h b/sys/dev/sound/pcm/vchan.h
--- a/sys/dev/sound/pcm/vchan.h
+++ b/sys/dev/sound/pcm/vchan.h
@@ -48,8 +48,8 @@
 
 #define VCHAN_SYNC_REQUIRED(c)						\
 	(((c)->flags & CHN_F_VIRTUAL) && (((c)->flags & CHN_F_DIRTY) ||	\
-	sndbuf_getfmt((c)->bufhard) != (c)->parentchannel->format ||	\
-	sndbuf_getspd((c)->bufhard) != (c)->parentchannel->speed))
+	(c)->bufhard->fmt != (c)->parentchannel->format ||		\
+	(c)->bufhard->spd != (c)->parentchannel->speed))
 
 void vchan_initsys(device_t);
 
diff --git a/sys/dev/sound/pcm/vchan.c b/sys/dev/sound/pcm/vchan.c
--- a/sys/dev/sound/pcm/vchan.c
+++ b/sys/dev/sound/pcm/vchan.c
@@ -492,7 +492,7 @@
 				}
 			}
 		}
-		*vchanrate = sndbuf_getspd(c->bufsoft);
+		*vchanrate = c->bufsoft->spd;
 
 		CHN_UNLOCK(c);
 	}
@@ -591,7 +591,7 @@
 				}
 			}
 		}
-		*vchanformat = sndbuf_getfmt(c->bufsoft);
+		*vchanformat = c->bufsoft->fmt;
 
 		CHN_UNLOCK(c);
 	}