/usr/src/usr.bin/sndiod/dev.c

Bug Summary

File:	src/usr.bin/sndiod/dev.c
Warning:	line 574, column 11 Division by zero
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name dev.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/sndiod/obj -resource-dir /usr/local/lib/clang/13.0.0 -D DEBUG -I /usr/src/usr.bin/sndiod/../../lib/libsndio -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/sndiod/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.bin/sndiod/dev.c
1/*	$OpenBSD: dev.c,v 1.103 2021/11/01 14:43:24 ratchov Exp $	*/
2/*
* Copyright (c) 2008-2012 Alexandre Ratchov <alex@caoua.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
17#include <stdio.h>
18#include <string.h>

20#include "abuf.h"
21#include "defs.h"
22#include "dev.h"
23#include "dsp.h"
24#include "siofile.h"
25#include "midi.h"
26#include "opt.h"
27#include "sysex.h"
28#include "utils.h"

30void zomb_onmove(void *);
31void zomb_onvol(void *);
32void zomb_fill(void *);
33void zomb_flush(void *);
34void zomb_eof(void *);
35void zomb_exit(void *);

37void dev_mix_badd(struct dev *, struct slot *);
38void dev_mix_adjvol(struct dev *);
39void dev_sub_bcopy(struct dev *, struct slot *);

41void dev_onmove(struct dev *, int);
42void dev_master(struct dev *, unsigned int);
43void dev_cycle(struct dev *);
44struct dev *dev_new(char *, struct aparams *, unsigned int, unsigned int,
  unsigned int, unsigned int, unsigned int, unsigned int);
46void dev_adjpar(struct dev *, int, int, int);
47int dev_allocbufs(struct dev *);
48void dev_freebufs(struct dev *);
49int dev_ref(struct dev *);
50void dev_unref(struct dev *);
51int dev_init(struct dev *);
52void dev_done(struct dev *);
53struct dev *dev_bynum(int);
54void dev_del(struct dev *);
55unsigned int dev_roundof(struct dev *, unsigned int);
56void dev_wakeup(struct dev *);

58void slot_ctlname(struct slot *, char *, size_t);
59void slot_log(struct slot *);
60void slot_del(struct slot *);
61void slot_setvol(struct slot *, unsigned int);
62void slot_ready(struct slot *);
63void slot_allocbufs(struct slot *);
64void slot_freebufs(struct slot *);
65void slot_skip_update(struct slot *);
66void slot_write(struct slot *);
67void slot_read(struct slot *);
68int slot_skip(struct slot *);

70void ctl_node_log(struct ctl_node *);
71void ctl_log(struct ctl *);

73struct slotops zomb_slotops = {
zomb_onmove,
zomb_onvol,
zomb_fill,
zomb_flush,
zomb_eof,
zomb_exit
80};

82struct ctl *ctl_list = NULL((void*)0);
83struct dev *dev_list = NULL((void*)0);
84unsigned int dev_sndnum = 0;

86struct ctlslot ctlslot_array[DEV_NCTLSLOT8];
87struct slot slot_array[DEV_NSLOT8];
88unsigned int slot_serial;		/* for slot allocation */

90/*
* we support/need a single MTC clock source only
*/
93struct mtc mtc_array[1] = {
{.dev = NULL((void*)0), .tstate = MTC_STOP1}
95};

97void
98slot_array_init(void)
99{
unsigned int i;

for (i = 0; i < DEV_NSLOT8; i++) {
slot_array[i].unit = i;
slot_array[i].ops = NULL((void*)0);
slot_array[i].vol = MIDI_MAXCTL127;
slot_array[i].opt = NULL((void*)0);
slot_array[i].serial = slot_serial++;
memset(slot_array[i].name, 0, SLOT_NAMEMAX8);
}
110}

112void
113dev_log(struct dev *d)
114{
115#ifdef DEBUG1
static char *pstates[] = {
"cfg", "ini", "run"
};
119#endif
log_puts("snd");
log_putu(d->num);
122#ifdef DEBUG1
if (log_level >= 3) {
log_puts(" pst=");
log_puts(pstates[d->pstate]);
}
127#endif
128}

130void
131slot_ctlname(struct slot *s, char *name, size_t size)
132{
snprintf(name, size, "%s%u", s->name, s->unit);
134}

136void
137slot_log(struct slot *s)
138{
char name[CTL_NAMEMAX16];
140#ifdef DEBUG1
static char *pstates[] = {
"ini", "sta", "rdy", "run", "stp", "mid"
};
144#endif
slot_ctlname(s, name, CTL_NAMEMAX16);
log_puts(name);
147#ifdef DEBUG1
if (log_level >= 3) {
log_puts(" vol=");
log_putu(s->vol);
if (s->ops) {
	log_puts(",pst=");
	log_puts(pstates[s->pstate]);
}
}
156#endif
157}

159void
160zomb_onmove(void *arg)
161{
162}

164void
165zomb_onvol(void *arg)
166{
167}

169void
170zomb_fill(void *arg)
171{
172}

174void
175zomb_flush(void *arg)
176{
177}

179void
180zomb_eof(void *arg)
181{
struct slot *s = arg;

184#ifdef DEBUG1
if (log_level >= 3) {
slot_log(s);
log_puts(": zomb_eof\n");
}
189#endif
s->ops = NULL((void*)0);
191}

193void
194zomb_exit(void *arg)
195{
196#ifdef DEBUG1
struct slot *s = arg;

if (log_level >= 3) {
slot_log(s);
log_puts(": zomb_exit\n");
}
203#endif
204}

206/*
* Broadcast MIDI data to all opts using this device
*/
209void
210dev_midi_send(struct dev *d, void *msg, int msglen)
211{
struct opt *o;

for (o = opt_list; o != NULL((void*)0); o = o->next) {
if (o->dev != d)
	continue;
midi_send(o->midi, msg, msglen);
}
219}

221/*
* send a quarter frame MTC message
*/
224void
225mtc_midi_qfr(struct mtc *mtc, int delta)
226{
unsigned char buf[2];
unsigned int data;
int qfrlen;

mtc->delta += delta * MTC_SEC2400;
qfrlen = mtc->dev->rate * (MTC_SEC2400 / (4 * mtc->fps));
while (mtc->delta >= qfrlen) {
switch (mtc->qfr) {
case 0:
	data = mtc->fr & 0xf;
	break;
case 1:
	data = mtc->fr >> 4;
	break;
case 2:
	data = mtc->sec & 0xf;
	break;
case 3:
	data = mtc->sec >> 4;
	break;
case 4:
	data = mtc->min & 0xf;
	break;
case 5:
	data = mtc->min >> 4;
	break;
case 6:
	data = mtc->hr & 0xf;
	break;
case 7:
	data = (mtc->hr >> 4) | (mtc->fps_id << 1);
	/*
	 * tick messages are sent 2 frames ahead
	 */
	mtc->fr += 2;
	if (mtc->fr < mtc->fps)
		break;
	mtc->fr -= mtc->fps;
	mtc->sec++;
	if (mtc->sec < 60)
		break;
	mtc->sec = 0;
	mtc->min++;
	if (mtc->min < 60)
		break;
	mtc->min = 0;
	mtc->hr++;
	if (mtc->hr < 24)
		break;
	mtc->hr = 0;
	break;
default:
	/* NOTREACHED */
	data = 0;
}
buf[0] = 0xf1;
buf[1] = (mtc->qfr << 4) | data;
mtc->qfr++;
mtc->qfr &= 7;
dev_midi_send(mtc->dev, buf, 2);
mtc->delta -= qfrlen;
}
289}

291/*
* send a full frame MTC message
*/
294void
295mtc_midi_full(struct mtc *mtc)
296{
struct sysex x;
unsigned int fps;

mtc->delta = -MTC_SEC2400 * (int)mtc->dev->bufsz;
if (mtc->dev->rate % (30 * 4 * mtc->dev->round) == 0) {
mtc->fps_id = MTC_FPS_303;
mtc->fps = 30;
} else if (mtc->dev->rate % (25 * 4 * mtc->dev->round) == 0) {
mtc->fps_id = MTC_FPS_251;
mtc->fps = 25;
} else {
mtc->fps_id = MTC_FPS_240;
mtc->fps = 24;
}
311#ifdef DEBUG1
if (log_level >= 3) {
dev_log(mtc->dev);
log_puts(": mtc full frame at ");
log_puti(mtc->delta);
log_puts(", ");
log_puti(mtc->fps);
log_puts(" fps\n");
}
320#endif
fps = mtc->fps;
mtc->hr =  (mtc->origin / (MTC_SEC2400 * 3600)) % 24;
mtc->min = (mtc->origin / (MTC_SEC2400 * 60))   % 60;
mtc->sec = (mtc->origin / (MTC_SEC2400))        % 60;
mtc->fr =  (mtc->origin / (MTC_SEC2400 / fps))  % fps;

x.start = SYSEX_START0xf0;
x.type = SYSEX_TYPE_RT0x7f;
x.dev = SYSEX_DEV_ANY0x7f;
x.id0 = SYSEX_MTC0x01;
x.id1 = SYSEX_MTC_FULL0x01;
x.u.full.hr = mtc->hr | (mtc->fps_id << 5);
x.u.full.min = mtc->min;
x.u.full.sec = mtc->sec;
x.u.full.fr = mtc->fr;
x.u.full.end = SYSEX_END0xf7;
mtc->qfr = 0;
dev_midi_send(mtc->dev, (unsigned char *)&x, SYSEX_SIZE(full)(5 + sizeof(struct sysex_full)));
339}

341/*
* send a volume change MIDI message
*/
344void
345dev_midi_vol(struct dev *d, struct slot *s)
346{
unsigned char msg[3];

msg[0] = MIDI_CTL0xb0 | (s - slot_array);
msg[1] = MIDI_CTL_VOL7;
msg[2] = s->vol;
dev_midi_send(d, msg, 3);
353}

355/*
* send a master volume MIDI message
*/
358void
359dev_midi_master(struct dev *d)
360{
struct ctl *c;
unsigned int master, v;
struct sysex x;

if (d->master_enabled)
master = d->master;
else {
master = 0;
for (c = ctl_list; c != NULL((void*)0); c = c->next) {
	if (c->type != CTL_NUM2 ||
	    strcmp(c->group, d->name) != 0 ||
	    strcmp(c->node0.name, "output") != 0 ||
	    strcmp(c->func, "level") != 0)
		continue;
	if (c->u.any.arg0 != d)
		continue;
	v = (c->curval * 127 + c->maxval / 2) / c->maxval;
	if (master < v)
		master = v;
}
}

memset(&x, 0, sizeof(struct sysex));
x.start = SYSEX_START0xf0;
x.type = SYSEX_TYPE_RT0x7f;
x.dev = SYSEX_DEV_ANY0x7f;
x.id0 = SYSEX_CONTROL0x04;
x.id1 = SYSEX_MASTER0x01;
x.u.master.fine = 0;
x.u.master.coarse = master;
x.u.master.end = SYSEX_END0xf7;
dev_midi_send(d, (unsigned char *)&x, SYSEX_SIZE(master)(5 + sizeof(struct sysex_master)));
393}

395/*
* send a sndiod-specific slot description MIDI message
*/
398void
399dev_midi_slotdesc(struct dev *d, struct slot *s)
400{
struct sysex x;

memset(&x, 0, sizeof(struct sysex));
x.start = SYSEX_START0xf0;
x.type = SYSEX_TYPE_EDU0x7d;
x.dev = SYSEX_DEV_ANY0x7f;
x.id0 = SYSEX_AUCAT0x23;
x.id1 = SYSEX_AUCAT_SLOTDESC0x01;
if (s->opt != NULL((void*)0) && s->opt->dev == d)
slot_ctlname(s, (char *)x.u.slotdesc.name, SYSEX_NAMELEN10);
x.u.slotdesc.chan = (s - slot_array);
x.u.slotdesc.end = SYSEX_END0xf7;
dev_midi_send(d, (unsigned char *)&x, SYSEX_SIZE(slotdesc)(5 + sizeof(struct sysex_slotdesc)));
414}

416void
417dev_midi_dump(struct dev *d)
418{
struct sysex x;
struct slot *s;
int i;

dev_midi_master(d);
for (i = 0, s = slot_array; i < DEV_NSLOT8; i++, s++) {
if (s->opt != NULL((void*)0) && s->opt->dev != d)
	continue;
dev_midi_slotdesc(d, s);
dev_midi_vol(d, s);
}
x.start = SYSEX_START0xf0;
x.type = SYSEX_TYPE_EDU0x7d;
x.dev = SYSEX_DEV_ANY0x7f;
x.id0 = SYSEX_AUCAT0x23;
x.id1 = SYSEX_AUCAT_DUMPEND0x03;
x.u.dumpend.end = SYSEX_END0xf7;
dev_midi_send(d, (unsigned char *)&x, SYSEX_SIZE(dumpend)(5 + sizeof(struct sysex_dumpend)));
437}

439int
440slot_skip(struct slot *s)
441{
unsigned char *data = (unsigned char *)0xdeadbeef; /* please gcc */
int max, count;

max = s->skip;
while (s->skip > 0) {
if (s->pstate != SLOT_STOP4 && (s->mode & MODE_RECMASK(0x02 | 0x10))) {
	data = abuf_wgetblk(&s->sub.buf, &count);
	if (count < s->round * s->sub.bpf)
		break;
}
if (s->mode & MODE_PLAY0x01) {
	if (s->mix.buf.used < s->round * s->mix.bpf)
		break;
}
456#ifdef DEBUG1
if (log_level >= 4) {
	slot_log(s);
	log_puts(": skipped a cycle\n");
}
461#endif
if (s->pstate != SLOT_STOP4 && (s->mode & MODE_RECMASK(0x02 | 0x10))) {
	if (s->sub.encbuf)
		enc_sil_do(&s->sub.enc, data, s->round);
	else
		memset(data, 0, s->round * s->sub.bpf);
	abuf_wcommit(&s->sub.buf, s->round * s->sub.bpf);
}
if (s->mode & MODE_PLAY0x01) {
	abuf_rdiscard(&s->mix.buf, s->round * s->mix.bpf);
}
s->skip--;
}
return max - s->skip;
475}

477/*
* Mix the slot input block over the output block
*/
480void
481dev_mix_badd(struct dev *d, struct slot *s)
482{
adata_t *idata, *odata, *in;
int icount, i, offs, vol, nch;

odata = DEV_PBUF(d)((d)->pbuf + (d)->poffs * (d)->pchan);
idata = (adata_t *)abuf_rgetblk(&s->mix.buf, &icount);
488#ifdef DEBUG1
if (icount < s->round * s->mix.bpf) {
slot_log(s);
log_puts(": not enough data to mix (");
log_putu(icount);
log_puts("bytes)\n");
panic();
}
496#endif
if (!(s->opt->mode & MODE_PLAY0x01)) {
/*
 * playback not allowed in opt structure, produce silence
 */
abuf_rdiscard(&s->mix.buf, s->round * s->mix.bpf);
return;
}


/*
* Apply the following processing chain:
*
*	dec -> resamp-> cmap
*
* where the first two are optional.
*/

in = idata;

if (s->mix.decbuf) {
dec_do(&s->mix.dec, (void *)in, s->mix.decbuf, s->round);
in = s->mix.decbuf;
}

if (s->mix.resampbuf) {
resamp_do(&s->mix.resamp, in, s->mix.resampbuf, s->round);
in = s->mix.resampbuf;
}

nch = s->mix.cmap.nch;
vol = ADATA_MUL(s->mix.weight, s->mix.vol)(((int)(s->mix.weight) * (int)(s->mix.vol)) >> (16
 - 1)) / s->mix.join;
cmap_add(&s->mix.cmap, in, odata, vol, d->round);

offs = 0;
for (i = s->mix.join - 1; i > 0; i--) {
offs += nch;
cmap_add(&s->mix.cmap, in + offs, odata, vol, d->round);
}

offs = 0;
for (i = s->mix.expand - 1; i > 0; i--) {
offs += nch;
cmap_add(&s->mix.cmap, in, odata + offs, vol, d->round);
}

abuf_rdiscard(&s->mix.buf, s->round * s->mix.bpf);
543}

545/*
* Normalize input levels.
*/
548void
549dev_mix_adjvol(struct dev *d)
550{
unsigned int n;
struct slot *i, *j;
int jcmax, icmax, weight;

for (i = d->slot_list; i25.1
'i' is not equal to NULL
 != NULL((void*)0); i = i->next) {
26
←
Loop condition is true.  Entering loop body→
if (!(i->mode & MODE_PLAY0x01))
27
←
Taking false branch→
	continue;
icmax = i->opt->pmin + i->mix.nch - 1;
weight = ADATA_UNIT(1 << (16 - 1));
if (d->autovol) {
28
←
Assuming field 'autovol' is not equal to 0→
29
←
Taking true branch→
	/*
	 * count the number of inputs that have
	 * overlapping channel sets
	 */
	n = 0;
30
←
The value 0 is assigned to 'n'→
	for (j = d->slot_list; j30.1
'j' is not equal to NULL
 != NULL((void*)0); j = j->next) {
31
←
Loop condition is true.  Entering loop body→
34
←
Assuming 'j' is equal to NULL→
35
←
Loop condition is false. Execution continues on line 574→
		if (!(j->mode & MODE_PLAY0x01))
32
←
Taking false branch→
			continue;
		jcmax = j->opt->pmin + j->mix.nch - 1;
		if (i->opt->pmin <= jcmax &&
33
←
Assuming 'jcmax' is < field 'pmin'→
		    icmax >= j->opt->pmin)
			n++;
	}
	weight /= n;
36
←
Division by zero
}
if (weight > i->opt->maxweight)
	weight = i->opt->maxweight;
i->mix.weight = d->master_enabled ?
    ADATA_MUL(weight, MIDI_TO_ADATA(d->master))(((int)(weight) * (int)((aparams_ctltovol[d->master] <<
 (16 - 16)))) >> (16 - 1)) : weight;
580#ifdef DEBUG1
if (log_level >= 3) {
	slot_log(i);
	log_puts(": set weight: ");
	log_puti(i->mix.weight);
	log_puts("/");
	log_puti(i->opt->maxweight);
	log_puts("\n");
}
589#endif
}
591}

593/*
* Copy data from slot to device
*/
596void
597dev_sub_bcopy(struct dev *d, struct slot *s)
598{
adata_t *idata, *enc_out, *resamp_out, *cmap_out;
void *odata;
int ocount, moffs;

int i, vol, offs, nch;


odata = (adata_t *)abuf_wgetblk(&s->sub.buf, &ocount);
607#ifdef DEBUG1
if (ocount < s->round * s->sub.bpf) {
log_puts("dev_sub_bcopy: not enough space\n");
panic();
}
612#endif
if (s->opt->mode & MODE_MON0x10) {
moffs = d->poffs + d->round;
if (moffs == d->psize)
	moffs = 0;
idata = d->pbuf + moffs * d->pchan;
} else if (s->opt->mode & MODE_REC0x02) {
idata = d->rbuf;
} else {
/*
 * recording not allowed in opt structure, produce silence
 */
enc_sil_do(&s->sub.enc, odata, s->round);
abuf_wcommit(&s->sub.buf, s->round * s->sub.bpf);
return;
}

/*
* Apply the following processing chain:
*
*	cmap -> resamp -> enc
*
* where the last two are optional.
*/

enc_out = odata;
resamp_out = s->sub.encbuf ? s->sub.encbuf : enc_out;
cmap_out = s->sub.resampbuf ? s->sub.resampbuf : resamp_out;

nch = s->sub.cmap.nch;
vol = ADATA_UNIT(1 << (16 - 1)) / s->sub.join;
cmap_copy(&s->sub.cmap, idata, cmap_out, vol, d->round);

offs = 0;
for (i = s->sub.join - 1; i > 0; i--) {
offs += nch;
cmap_add(&s->sub.cmap, idata + offs, cmap_out, vol, d->round);
}

offs = 0;
for (i = s->sub.expand - 1; i > 0; i--) {
offs += nch;
cmap_copy(&s->sub.cmap, idata, cmap_out + offs, vol, d->round);
}

if (s->sub.resampbuf) {
resamp_do(&s->sub.resamp,
    s->sub.resampbuf, resamp_out, d->round);
}

if (s->sub.encbuf)
enc_do(&s->sub.enc, s->sub.encbuf, (void *)enc_out, s->round);

abuf_wcommit(&s->sub.buf, s->round * s->sub.bpf);
666}

668/*
* run a one block cycle: consume one recorded block from
* rbuf and produce one play block in pbuf
*/
672void
673dev_cycle(struct dev *d)
674{
struct slot *s, **ps;
unsigned char *base;
int nsamp;

/*
* check if the device is actually used. If it isn't,
* then close it
*/
if (d->slot_list == NULL((void*)0) && (mtc_array[0].dev != d ||
   mtc_array[0].tstate != MTC_RUN3)) {
if (log_level >= 2) {
	dev_log(d);
	log_puts(": device stopped\n");
}
dev_sio_stop(d);
d->pstate = DEV_INIT1;
if (d->refcnt == 0)
	dev_close(d);
return;
}

if (d->prime > 0) {
697#ifdef DEBUG1
if (log_level >= 4) {
	dev_log(d);
	log_puts(": empty cycle, prime = ");
	log_putu(d->prime);
	log_puts("\n");
}
704#endif
base = (unsigned char *)DEV_PBUF(d)((d)->pbuf + (d)->poffs * (d)->pchan);
nsamp = d->round * d->pchan;
memset(base, 0, nsamp * sizeof(adata_t));
if (d->encbuf) {
	enc_do(&d->enc, (unsigned char *)DEV_PBUF(d)((d)->pbuf + (d)->poffs * (d)->pchan),
	    d->encbuf, d->round);
}
d->prime -= d->round;
return;
}

d->delta -= d->round;
717#ifdef DEBUG1
if (log_level >= 4) {
dev_log(d);
log_puts(": full cycle: delta = ");
log_puti(d->delta);
if (d->mode & MODE_PLAY0x01) {
	log_puts(", poffs = ");
	log_puti(d->poffs);
}
log_puts("\n");
}
728#endif
if (d->mode & MODE_PLAY0x01) {
base = (unsigned char *)DEV_PBUF(d)((d)->pbuf + (d)->poffs * (d)->pchan);
nsamp = d->round * d->pchan;
memset(base, 0, nsamp * sizeof(adata_t));
}
if ((d->mode & MODE_REC0x02) && d->decbuf)
dec_do(&d->dec, d->decbuf, (unsigned char *)d->rbuf, d->round);
ps = &d->slot_list;
while ((s = *ps) != NULL((void*)0)) {
738#ifdef DEBUG1
if (log_level >= 4) {
	slot_log(s);
	log_puts(": running");
	log_puts(", skip = ");
	log_puti(s->skip);
	log_puts("\n");
}
746#endif
/*
 * skip cycles for XRUN_SYNC correction
 */
slot_skip(s);
if (s->skip < 0) {
	s->skip++;
	ps = &s->next;
	continue;
}

757#ifdef DEBUG1
if (s->pstate == SLOT_STOP4 && !(s->mode & MODE_PLAY0x01)) {
	slot_log(s);
	log_puts(": rec-only slots can't be drained\n");
	panic();
}
763#endif
/*
 * check if stopped stream finished draining
 */
if (s->pstate == SLOT_STOP4 &&
    s->mix.buf.used < s->round * s->mix.bpf) {
	/*
	 * partial blocks are zero-filled by socket
	 * layer, so s->mix.buf.used == 0 and we can
	 * destroy the buffer
	 */
	*ps = s->next;
	s->pstate = SLOT_INIT0;
	s->ops->eof(s->arg);
	slot_freebufs(s);
	dev_mix_adjvol(d);
779#ifdef DEBUG1
	if (log_level >= 3) {
		slot_log(s);
		log_puts(": drained\n");
	}
784#endif
	continue;
}

/*
 * check for xruns
 */
if (((s->mode & MODE_PLAY0x01) &&
	s->mix.buf.used < s->round * s->mix.bpf) ||
    ((s->mode & MODE_RECMASK(0x02 | 0x10)) &&
	s->sub.buf.len - s->sub.buf.used <
	s->round * s->sub.bpf)) {

797#ifdef DEBUG1
	if (log_level >= 3) {
		slot_log(s);
		log_puts(": xrun, pause cycle\n");
	}
802#endif
	if (s->xrun == XRUN_IGNORE0) {
		s->delta -= s->round;
		ps = &s->next;
	} else if (s->xrun == XRUN_SYNC1) {
		s->skip++;
		ps = &s->next;
	} else if (s->xrun == XRUN_ERROR2) {
		s->ops->exit(s->arg);
		*ps = s->next;
	} else {
813#ifdef DEBUG1
		slot_log(s);
		log_puts(": bad xrun mode\n");
		panic();
817#endif
	}
	continue;
}
if ((s->mode & MODE_RECMASK(0x02 | 0x10)) && !(s->pstate == SLOT_STOP4)) {
	if (s->sub.prime == 0) {
		dev_sub_bcopy(d, s);
		s->ops->flush(s->arg);
	} else {
826#ifdef DEBUG1
		if (log_level >= 3) {
			slot_log(s);
			log_puts(": prime = ");
			log_puti(s->sub.prime);
			log_puts("\n");
		}
833#endif
		s->sub.prime--;
	}
}
if (s->mode & MODE_PLAY0x01) {
	dev_mix_badd(d, s);
	if (s->pstate != SLOT_STOP4)
		s->ops->fill(s->arg);
}
ps = &s->next;
}
if ((d->mode & MODE_PLAY0x01) && d->encbuf) {
enc_do(&d->enc, (unsigned char *)DEV_PBUF(d)((d)->pbuf + (d)->poffs * (d)->pchan),
    d->encbuf, d->round);
}
848}

850/*
* called at every clock tick by the device
*/
853void
854dev_onmove(struct dev *d, int delta)
855{
long long pos;
struct slot *s, *snext;

d->delta += delta;

for (s = d->slot_list; s != NULL((void*)0); s = snext) {
/*
 * s->ops->onmove() may remove the slot
 */
snext = s->next;
pos = s->delta_rem +
    (long long)s->delta * d->round +
    (long long)delta * s->round;
s->delta = pos / (int)d->round;
s->delta_rem = pos % d->round;
if (s->delta_rem < 0) {
	s->delta_rem += d->round;
	s->delta--;
}
if (s->delta >= 0)
	s->ops->onmove(s->arg);
}

if (mtc_array[0].dev == d && mtc_array[0].tstate == MTC_RUN3)
mtc_midi_qfr(&mtc_array[0], delta);
881}

883void
884dev_master(struct dev *d, unsigned int master)
885{
struct ctl *c;
unsigned int v;

if (log_level >= 2) {
dev_log(d);
log_puts(": master volume set to ");
log_putu(master);
log_puts("\n");
}
if (d->master_enabled) {
d->master = master;
if (d->mode & MODE_PLAY0x01)
	dev_mix_adjvol(d);
} else {
for (c = ctl_list; c != NULL((void*)0); c = c->next) {
	if (c->scope != CTL_HW0 || c->u.hw.dev != d)
		continue;
	if (c->type != CTL_NUM2 ||
	    strcmp(c->group, d->name) != 0 ||
	    strcmp(c->node0.name, "output") != 0 ||
	    strcmp(c->func, "level") != 0)
		continue;
	v = (master * c->maxval + 64) / 127;
	ctl_setval(c, v);
}
}
912}

914/*
* Create a sndio device
*/
917struct dev *
918dev_new(char *path, struct aparams *par,
  unsigned int mode, unsigned int bufsz, unsigned int round,
  unsigned int rate, unsigned int hold, unsigned int autovol)
921{
struct dev *d, **pd;

if (dev_sndnum == DEV_NMAX16) {
if (log_level >= 1)
	log_puts("too many devices\n");
return NULL((void*)0);
}
d = xmalloc(sizeof(struct dev));
d->path = path;
d->num = dev_sndnum++;

d->reqpar = *par;
d->reqmode = mode;
d->reqpchan = d->reqrchan = 0;
d->reqbufsz = bufsz;
d->reqround = round;
d->reqrate = rate;
d->hold = hold;
d->autovol = autovol;
d->refcnt = 0;
d->pstate = DEV_CFG0;
d->slot_list = NULL((void*)0);
d->master = MIDI_MAXCTL127;
d->master_enabled = 0;
d->alt_next = d;
snprintf(d->name, CTL_NAMEMAX16, "%u", d->num);
for (pd = &dev_list; *pd != NULL((void*)0); pd = &(*pd)->next)
;
d->next = *pd;
*pd = d;
return d;
953}

955/*
* adjust device parameters and mode
*/
958void
959dev_adjpar(struct dev *d, int mode,
  int pmax, int rmax)
961{
d->reqmode |= mode & MODE_AUDIOMASK(0x01 | 0x02 | 0x10);
if (mode & MODE_PLAY0x01) {
if (d->reqpchan < pmax + 1)
	d->reqpchan = pmax + 1;
}
if (mode & MODE_REC0x02) {
if (d->reqrchan < rmax + 1)
	d->reqrchan = rmax + 1;
}
971}

973/*
* Open the device with the dev_reqxxx capabilities. Setup a mixer, demuxer,
* monitor, midi control, and any necessary conversions.
*
* Note that record and play buffers are always allocated, even if the
* underlying device doesn't support both modes.
*/
980int
981dev_allocbufs(struct dev *d)
982{
/*
* Create record buffer.
*/

/* Create device <-> demuxer buffer */
d->rbuf = xmalloc(d->round * d->rchan * sizeof(adata_t));

/* Insert a converter, if needed. */
if (!aparams_native(&d->par)) {
dec_init(&d->dec, &d->par, d->rchan);
d->decbuf = xmalloc(d->round * d->rchan * d->par.bps);
} else
d->decbuf = NULL((void*)0);

/*
* Create play buffer
*/

/* Create device <-> mixer buffer */
d->poffs = 0;
d->psize = d->bufsz + d->round;
d->pbuf = xmalloc(d->psize * d->pchan * sizeof(adata_t));
d->mode |= MODE_MON0x10;

/* Append a converter, if needed. */
if (!aparams_native(&d->par)) {
enc_init(&d->enc, &d->par, d->pchan);
d->encbuf = xmalloc(d->round * d->pchan * d->par.bps);
} else
d->encbuf = NULL((void*)0);

/*
* Initially fill the record buffer with zeroed samples. This ensures
* that when a client records from a play-only device the client just
* gets silence.
*/
memset(d->rbuf, 0, d->round * d->rchan * sizeof(adata_t));

if (log_level >= 2) {
dev_log(d);
log_puts(": ");
log_putu(d->rate);
log_puts("Hz, ");
aparams_log(&d->par);
if (d->mode & MODE_PLAY0x01) {
	log_puts(", play 0:");
	log_puti(d->pchan - 1);
}
if (d->mode & MODE_REC0x02) {
	log_puts(", rec 0:");
	log_puti(d->rchan - 1);
}
log_puts(", ");
log_putu(d->bufsz / d->round);
log_puts(" blocks of ");
log_putu(d->round);
log_puts(" frames");
if (d == mtc_array[0].dev)
	log_puts(", mtc");
log_puts("\n");
}
return 1;
1045}

1047/*
* Reset parameters and open the device.
*/
1050int
1051dev_open(struct dev *d)
1052{
d->mode = d->reqmode;
d->round = d->reqround;
d->bufsz = d->reqbufsz;
d->rate = d->reqrate;
d->pchan = d->reqpchan;
d->rchan = d->reqrchan;
d->par = d->reqpar;
if (d->pchan == 0)
d->pchan = 2;
if (d->rchan == 0)
d->rchan = 2;
if (!dev_sio_open(d)) {
if (log_level >= 1) {
	dev_log(d);
	log_puts(": failed to open audio device\n");
}
return 0;
}
if (!dev_allocbufs(d))
return 0;

d->pstate = DEV_INIT1;
return 1;
1076}

1078/*
* Force all slots to exit and close device, called after an error
*/
1081void
1082dev_abort(struct dev *d)
1083{
int i;
struct slot *s;
struct ctlslot *c;
struct opt *o;

for (i = 0, s = slot_array; i < DEV_NSLOT8; i++, s++) {
if (s->opt == NULL((void*)0) || s->opt->dev != d)
	continue;
if (s->ops) {
	s->ops->exit(s->arg);
	s->ops = NULL((void*)0);
}
}
d->slot_list = NULL((void*)0);

for (o = opt_list; o != NULL((void*)0); o = o->next) {
if (o->dev != d)
	continue;
for (c = ctlslot_array, i = 0; i < DEV_NCTLSLOT8; i++, c++) {
	if (c->ops == NULL((void*)0))
		continue;
	if (c->opt == o) {
		c->ops->exit(s->arg);
		c->ops = NULL((void*)0);
	}
}

midi_abort(o->midi);
}

if (d->pstate != DEV_CFG0)
dev_close(d);
1116}

1118/*
* force the device to go in DEV_CFG state, the caller is supposed to
* ensure buffers are drained
*/
1122void
1123dev_freebufs(struct dev *d)
1124{
1125#ifdef DEBUG1
if (log_level >= 3) {
dev_log(d);
log_puts(": closing\n");
}
1130#endif
if (d->mode & MODE_PLAY0x01) {
if (d->encbuf != NULL((void*)0))
	xfree(d->encbuf);
xfree(d->pbuf);
}
if (d->mode & MODE_REC0x02) {
if (d->decbuf != NULL((void*)0))
	xfree(d->decbuf);
xfree(d->rbuf);
}
1141}

1143/*
* Close the device and exit all slots
*/
1146void
1147dev_close(struct dev *d)
1148{
d->pstate = DEV_CFG0;
dev_sio_close(d);
dev_freebufs(d);

if (d->master_enabled) {
d->master_enabled = 0;
ctl_del(CTL_DEV_MASTER1, d, NULL((void*)0));
}
1157}

1159int
1160dev_ref(struct dev *d)
1161{
1162#ifdef DEBUG1
if (log_level >= 3) {
dev_log(d);
log_puts(": device requested\n");
}
1167#endif
if (d->pstate == DEV_CFG0 && !dev_open(d))
return 0;
d->refcnt++;
return 1;
1172}

1174void
1175dev_unref(struct dev *d)
1176{
1177#ifdef DEBUG1
if (log_level >= 3) {
dev_log(d);
log_puts(": device released\n");
}
1182#endif
d->refcnt--;
if (d->refcnt == 0 && d->pstate == DEV_INIT1)
dev_close(d);
1186}

1188/*
* initialize the device with the current parameters
*/
1191int
1192dev_init(struct dev *d)
1193{
if ((d->reqmode & MODE_AUDIOMASK(0x01 | 0x02 | 0x10)) == 0) {
1195#ifdef DEBUG1
    dev_log(d);
    log_puts(": has no streams\n");
1198#endif
    return 0;
}
if (d->hold && !dev_ref(d))
return 0;
return 1;
1204}

1206/*
* Unless the device is already in process of closing, request it to close
*/
1209void
1210dev_done(struct dev *d)
1211{
1212#ifdef DEBUG1
if (log_level >= 3) {
dev_log(d);
log_puts(": draining\n");
}
1217#endif
if (mtc_array[0].dev == d && mtc_array[0].tstate != MTC_STOP1)
mtc_stop(&mtc_array[0]);
if (d->hold)
dev_unref(d);
1222}

1224struct dev *
1225dev_bynum(int num)
1226{
struct dev *d;

for (d = dev_list; d != NULL((void*)0); d = d->next) {
if (d->num == num)
	return d;
}
return NULL((void*)0);
1234}

1236/*
* Free the device
*/
1239void
1240dev_del(struct dev *d)
1241{
struct dev **p;

1244#ifdef DEBUG1
if (log_level >= 3) {
dev_log(d);
log_puts(": deleting\n");
}
1249#endif
if (d->pstate != DEV_CFG0)
dev_close(d);
for (p = &dev_list; *p != d; p = &(*p)->next) {
1253#ifdef DEBUG1
if (*p == NULL((void*)0)) {
	dev_log(d);
	log_puts(": device to delete not on the list\n");
	panic();
}
1259#endif
}
*p = d->next;
xfree(d);
1263}

1265unsigned int
1266dev_roundof(struct dev *d, unsigned int newrate)
1267{
return (d->round * newrate + d->rate / 2) / d->rate;
1269}

1271/*
* If the device is paused, then resume it.
*/
1274void
1275dev_wakeup(struct dev *d)
1276{
if (d->pstate == DEV_INIT1) {
15
←
Assuming field 'pstate' is not equal to DEV_INIT→
16
←
Taking false branch→
if (log_level >= 2) {
	dev_log(d);
	log_puts(": device started\n");
}
if (d->mode & MODE_PLAY0x01) {
	d->prime = d->bufsz;
} else {
	d->prime = 0;
}
d->poffs = 0;

/*
 * empty cycles don't increment delta, so it's ok to
 * start at 0
 **/
d->delta = 0;

d->pstate = DEV_RUN2;
dev_sio_start(d);
}
1298}
17
←
Returning without writing to 'd->autovol', which participates in a condition later→

1300/*
* Return true if both of the given devices can run the same
* clients
*/
1304int
1305dev_iscompat(struct dev *o, struct dev *n)
1306{
if (((long long)o->round * n->rate != (long long)n->round * o->rate) ||
   ((long long)o->bufsz * n->rate != (long long)n->bufsz * o->rate)) {
if (log_level >= 1) {
	log_puts(n->name);
	log_puts(": not compatible with ");
	log_puts(o->name);
	log_puts("\n");
}
return 0;
}
return 1;
1318}

1320/*
* Close the device, but attempt to migrate everything to a new sndio
* device.
*/
1324struct dev *
1325dev_migrate(struct dev *odev)
1326{
struct dev *ndev;
struct opt *o;
struct slot *s;
int i;

/* not opened */
if (odev->pstate == DEV_CFG0)
return odev;

ndev = odev;
while (1) {
/* try next one, circulating through the list */
ndev = ndev->alt_next;
if (ndev == odev) {
	if (log_level >= 1) {
		dev_log(odev);
		log_puts(": no fall-back device found\n");
	}
	return NULL((void*)0);
}


if (!dev_ref(ndev))
	continue;

/* check if new parameters are compatible with old ones */
if (!dev_iscompat(odev, ndev)) {
	dev_unref(ndev);
	continue;
}

/* found it!*/
break;
}

if (log_level >= 1) {
dev_log(odev);
log_puts(": switching to ");
dev_log(ndev);
log_puts("\n");
}

if (mtc_array[0].dev == odev)
mtc_setdev(&mtc_array[0], ndev);

/* move opts to new device (also moves clients using the opts) */
for (o = opt_list; o != NULL((void*)0); o = o->next) {
if (o->dev != odev)
	continue;
if (strcmp(o->name, o->dev->name) == 0)
	continue;
opt_setdev(o, ndev);
}

/* terminate remaining clients */
for (i = 0, s = slot_array; i < DEV_NSLOT8; i++, s++) {
if (s->opt == NULL((void*)0) || s->opt->dev != odev)
	continue;
if (s->ops != NULL((void*)0)) {
	s->ops->exit(s);
	s->ops = NULL((void*)0);
}
}

/* slots and/or MMC hold refs, drop ours */
dev_unref(ndev);

return ndev;
1395}

1397/*
* check that all clients controlled by MMC are ready to start, if so,
* attach them all at the same position
*/
1401void
1402mtc_trigger(struct mtc *mtc)
1403{
int i;
struct slot *s;

if (mtc->tstate != MTC_START2) {
if (log_level >= 2) {
	dev_log(mtc->dev);
	log_puts(": not started by mmc yet, waiting...\n");
}
return;
}

for (i = 0, s = slot_array; i < DEV_NSLOT8; i++, s++) {
if (s->opt == NULL((void*)0) || s->opt->mtc != mtc)
	continue;
if (s->pstate != SLOT_READY2) {
1419#ifdef DEBUG1
	if (log_level >= 3) {
		slot_log(s);
		log_puts(": not ready, start delayed\n");
	}
1424#endif
	return;
}
}
if (!dev_ref(mtc->dev))
return;

for (i = 0, s = slot_array; i < DEV_NSLOT8; i++, s++) {
if (s->opt == NULL((void*)0) || s->opt->mtc != mtc)
	continue;
slot_attach(s);
s->pstate = SLOT_RUN3;
}
mtc->tstate = MTC_RUN3;
mtc_midi_full(mtc);
dev_wakeup(mtc->dev);
1440}

1442/*
* start all slots simultaneously
*/
1445void
1446mtc_start(struct mtc *mtc)
1447{
if (mtc->tstate == MTC_STOP1) {
mtc->tstate = MTC_START2;
mtc_trigger(mtc);
1451#ifdef DEBUG1
} else {
if (log_level >= 3) {
	dev_log(mtc->dev);
	log_puts(": ignoring mmc start\n");
}
1457#endif
}
1459}

1461/*
* stop all slots simultaneously
*/
1464void
1465mtc_stop(struct mtc *mtc)
1466{
switch (mtc->tstate) {
case MTC_START2:
mtc->tstate = MTC_STOP1;
return;
case MTC_RUN3:
mtc->tstate = MTC_STOP1;
dev_unref(mtc->dev);
break;
default:
1476#ifdef DEBUG1
if (log_level >= 3) {
	dev_log(mtc->dev);
	log_puts(": ignored mmc stop\n");
}
1481#endif
return;
}
1484}

1486/*
* relocate all slots simultaneously
*/
1489void
1490mtc_loc(struct mtc *mtc, unsigned int origin)
1491{
if (log_level >= 2) {
dev_log(mtc->dev);
log_puts(": relocated to ");
log_putu(origin);
log_puts("\n");
}
if (mtc->tstate == MTC_RUN3)
mtc_stop(mtc);
mtc->origin = origin;
if (mtc->tstate == MTC_RUN3)
mtc_start(mtc);
1503}

1505/*
* set MMC device
*/
1508void
1509mtc_setdev(struct mtc *mtc, struct dev *d)
1510{
struct opt *o;

if (mtc->dev == d)
return;

if (log_level >= 2) {
dev_log(d);
log_puts(": set to be MIDI clock source\n");
}

/* adjust clock and ref counter, if needed */
if (mtc->tstate == MTC_RUN3) {
mtc->delta -= mtc->dev->delta;
dev_unref(mtc->dev);
}

mtc->dev = d;

if (mtc->tstate == MTC_RUN3) {
mtc->delta += mtc->dev->delta;
dev_ref(mtc->dev);
dev_wakeup(mtc->dev);
}

/* move in once anything using MMC */
for (o = opt_list; o != NULL((void*)0); o = o->next) {
if (o->mtc == mtc)
	opt_setdev(o, mtc->dev);
}
1540}

1542/*
* allocate buffers & conversion chain
*/
1545void
1546slot_initconv(struct slot *s)
1547{
unsigned int dev_nch;
struct dev *d = s->opt->dev;

if (s->mode & MODE_PLAY0x01) {
cmap_init(&s->mix.cmap,
    s->opt->pmin, s->opt->pmin + s->mix.nch - 1,
    s->opt->pmin, s->opt->pmin + s->mix.nch - 1,
    0, d->pchan - 1,
    s->opt->pmin, s->opt->pmax);
s->mix.decbuf = NULL((void*)0);
s->mix.resampbuf = NULL((void*)0);
if (!aparams_native(&s->par)) {
	dec_init(&s->mix.dec, &s->par, s->mix.nch);
	s->mix.decbuf =
	    xmalloc(s->round * s->mix.nch * sizeof(adata_t));
}
if (s->rate != d->rate) {
	resamp_init(&s->mix.resamp, s->round, d->round,
	    s->mix.nch);
	s->mix.resampbuf =
	    xmalloc(d->round * s->mix.nch * sizeof(adata_t));
}
s->mix.join = 1;
s->mix.expand = 1;
if (s->opt->dup && s->mix.cmap.nch > 0) {
	dev_nch = d->pchan < (s->opt->pmax + 1) ?
	    d->pchan - s->opt->pmin :
	    s->opt->pmax - s->opt->pmin + 1;
	if (dev_nch > s->mix.nch)
		s->mix.expand = dev_nch / s->mix.nch;
	else if (s->mix.nch > dev_nch)
		s->mix.join = s->mix.nch / dev_nch;
}
}

if (s->mode & MODE_RECMASK(0x02 | 0x10)) {
unsigned int outchan = (s->opt->mode & MODE_MON0x10) ?
    d->pchan : d->rchan;

s->sub.encbuf = NULL((void*)0);
s->sub.resampbuf = NULL((void*)0);
cmap_init(&s->sub.cmap,
    0, outchan - 1,
    s->opt->rmin, s->opt->rmax,
    s->opt->rmin, s->opt->rmin + s->sub.nch - 1,
    s->opt->rmin, s->opt->rmin + s->sub.nch - 1);
if (s->rate != d->rate) {
	resamp_init(&s->sub.resamp, d->round, s->round,
	    s->sub.nch);
	s->sub.resampbuf =
	    xmalloc(d->round * s->sub.nch * sizeof(adata_t));
}
if (!aparams_native(&s->par)) {
	enc_init(&s->sub.enc, &s->par, s->sub.nch);
	s->sub.encbuf =
	    xmalloc(s->round * s->sub.nch * sizeof(adata_t));
}
s->sub.join = 1;
s->sub.expand = 1;
if (s->opt->dup && s->sub.cmap.nch > 0) {
	dev_nch = outchan < (s->opt->rmax + 1) ?
	    outchan - s->opt->rmin :
	    s->opt->rmax - s->opt->rmin + 1;
	if (dev_nch > s->sub.nch)
		s->sub.join = dev_nch / s->sub.nch;
	else if (s->sub.nch > dev_nch)
		s->sub.expand = s->sub.nch / dev_nch;
}

/*
 * cmap_copy() doesn't write samples in all channels,
        * for instance when mono->stereo conversion is
        * disabled. So we have to prefill cmap_copy() output
        * with silence.
        */
if (s->sub.resampbuf) {
	memset(s->sub.resampbuf, 0,
	    d->round * s->sub.nch * sizeof(adata_t));
} else if (s->sub.encbuf) {
	memset(s->sub.encbuf, 0,
	    s->round * s->sub.nch * sizeof(adata_t));
} else {
	memset(s->sub.buf.data, 0,
	    s->appbufsz * s->sub.nch * sizeof(adata_t));
}
}
1634}

1636/*
* allocate buffers & conversion chain
*/
1639void
1640slot_allocbufs(struct slot *s)
1641{
if (s->mode & MODE_PLAY0x01) {
s->mix.bpf = s->par.bps * s->mix.nch;
abuf_init(&s->mix.buf, s->appbufsz * s->mix.bpf);
}

if (s->mode & MODE_RECMASK(0x02 | 0x10)) {
s->sub.bpf = s->par.bps * s->sub.nch;
abuf_init(&s->sub.buf, s->appbufsz * s->sub.bpf);
}

1652#ifdef DEBUG1
if (log_level >= 3) {
slot_log(s);
log_puts(": allocated ");
log_putu(s->appbufsz);
log_puts("/");
log_putu(SLOT_BUFSZ(s)((s)->appbufsz + (s)->opt->dev->bufsz / (s)->opt
->dev->round * (s)->round));
log_puts(" fr buffers\n");
}
1661#endif
1662}

1664/*
* free buffers & conversion chain
*/
1667void
1668slot_freebufs(struct slot *s)
1669{
if (s->mode & MODE_RECMASK(0x02 | 0x10)) {
abuf_done(&s->sub.buf);
}

if (s->mode & MODE_PLAY0x01) {
abuf_done(&s->mix.buf);
}
1677}

1679/*
* allocate a new slot and register the given call-backs
*/
1682struct slot *
1683slot_new(struct opt *opt, unsigned int id, char *who,
  struct slotops *ops, void *arg, int mode)
1685{
char *p;
char name[SLOT_NAMEMAX8];
char ctl_name[CTL_NAMEMAX16];
unsigned int i, ser, bestser, bestidx;
struct slot *unit[DEV_NSLOT8];
struct slot *s;

/*
* create a ``valid'' control name (lowcase, remove [^a-z], truncate)
*/
for (i = 0, p = who; ; p++) {
if (i == SLOT_NAMEMAX8 - 1 || *p == '\0') {
	name[i] = '\0';
	break;
} else if (*p >= 'A' && *p <= 'Z') {
	name[i++] = *p + 'a' - 'A';
} else if (*p >= 'a' && *p <= 'z')
	name[i++] = *p;
}
if (i == 0)
strlcpy(name, "noname", SLOT_NAMEMAX8);

/*
* build a unit-to-slot map for this name
*/
for (i = 0; i < DEV_NSLOT8; i++)
unit[i] = NULL((void*)0);
for (i = 0, s = slot_array; i < DEV_NSLOT8; i++, s++) {
if (strcmp(s->name, name) == 0)
	unit[s->unit] = s;
}

/*
* find the free slot with the least unit number and same id
*/
for (i = 0; i < DEV_NSLOT8; i++) {
s = unit[i];
if (s != NULL((void*)0) && s->ops == NULL((void*)0) && s->id == id)
	goto found;
}

/*
* find the free slot with the least unit number
*/
for (i = 0; i < DEV_NSLOT8; i++) {
s = unit[i];
if (s != NULL((void*)0) && s->ops == NULL((void*)0)) {
	s->id = id;
	goto found;
}
}

/*
* couldn't find a matching slot, pick oldest free slot
* and set its name/unit
*/
bestser = 0;
bestidx = DEV_NSLOT8;
for (i = 0, s = slot_array; i < DEV_NSLOT8; i++, s++) {
if (s->ops != NULL((void*)0))
	continue;
ser = slot_serial - s->serial;
if (ser > bestser) {
	bestser = ser;
	bestidx = i;
}
}

if (bestidx == DEV_NSLOT8) {
if (log_level >= 1) {
	log_puts(name);
	log_puts(": out of sub-device slots\n");
}
return NULL((void*)0);
}

s = slot_array + bestidx;
ctl_del(CTL_SLOT_LEVEL3, s, NULL((void*)0));
s->vol = MIDI_MAXCTL127;
strlcpy(s->name, name, SLOT_NAMEMAX8);
s->serial = slot_serial++;
for (i = 0; unit[i] != NULL((void*)0); i++)
; /* nothing */
s->unit = i;
s->id = id;
s->opt = opt;
slot_ctlname(s, ctl_name, CTL_NAMEMAX16);
ctl_new(CTL_SLOT_LEVEL3, s, NULL((void*)0),
   CTL_NUM2, "app", ctl_name, -1, "level",
   NULL((void*)0), -1, 127, s->vol);

1777found:
/* open device, this may change opt's device */
if (!opt_ref(s->opt))
return NULL((void*)0);
s->opt = opt;
s->ops = ops;
s->arg = arg;
s->pstate = SLOT_INIT0;
s->mode = mode;
aparams_init(&s->par);
if (s->mode & MODE_PLAY0x01)
s->mix.nch = s->opt->pmax - s->opt->pmin + 1;
if (s->mode & MODE_RECMASK(0x02 | 0x10))
s->sub.nch = s->opt->rmax - s->opt->rmin + 1;
s->xrun = s->opt->mtc != NULL((void*)0) ? XRUN_SYNC1 : XRUN_IGNORE0;
s->appbufsz = s->opt->dev->bufsz;
s->round = s->opt->dev->round;
s->rate = s->opt->dev->rate;
dev_midi_slotdesc(s->opt->dev, s);
dev_midi_vol(s->opt->dev, s);
1797#ifdef DEBUG1
if (log_level >= 3) {
slot_log(s);
log_puts(": using ");
log_puts(s->opt->name);
log_puts(", mode = ");
log_putx(mode);
log_puts("\n");
}
1806#endif
return s;
1808}

1810/*
* release the given slot
*/
1813void
1814slot_del(struct slot *s)
1815{
s->arg = s;
s->ops = &zomb_slotops;
switch (s->pstate) {
case SLOT_INIT0:
s->ops = NULL((void*)0);
break;
case SLOT_START1:
case SLOT_READY2:
case SLOT_RUN3:
case SLOT_STOP4:
slot_stop(s, 0);
break;
}
opt_unref(s->opt);
1830}

1832/*
* change the slot play volume; called either by the slot or by MIDI
*/
1835void
1836slot_setvol(struct slot *s, unsigned int vol)
1837{
1838#ifdef DEBUG1
if (log_level >= 3) {
slot_log(s);
log_puts(": setting volume ");
log_putu(vol);
log_puts("\n");
}
1845#endif
s->vol = vol;
s->mix.vol = MIDI_TO_ADATA(s->vol)(aparams_ctltovol[s->vol] << (16 - 16));
1848}

1850/*
* set device for this slot
*/
1853void
1854slot_setopt(struct slot *s, struct opt *o)
1855{
struct opt *t;
struct dev *odev, *ndev;
struct ctl *c;

if (s->opt == NULL((void*)0) || s->opt == o)
return;

if (log_level >= 2) {
slot_log(s);
log_puts(": moving to opt ");
log_puts(o->name);
log_puts("\n");
}

odev = s->opt->dev;
if (s->ops != NULL((void*)0)) {
ndev = opt_ref(o);
if (ndev == NULL((void*)0))
	return;

if (!dev_iscompat(odev, ndev)) {
	opt_unref(o);
	return;
}
}

if (s->pstate == SLOT_RUN3 || s->pstate == SLOT_STOP4)
slot_detach(s);

t = s->opt;
s->opt = o;

c = ctl_find(CTL_SLOT_LEVEL3, s, NULL((void*)0));
ctl_update(c);

if (o->dev != t->dev) {
dev_midi_slotdesc(odev, s);
dev_midi_slotdesc(ndev, s);
dev_midi_vol(ndev, s);
}

if (s->pstate == SLOT_RUN3 || s->pstate == SLOT_STOP4)
slot_attach(s);

if (s->ops != NULL((void*)0)) {
opt_unref(t);
return;
}
1904}

1906/*
* attach the slot to the device (ie start playing & recording
*/
1909void
1910slot_attach(struct slot *s)
1911{
struct dev *d = s->opt->dev;
long long pos;

if (((s->mode & MODE_PLAY0x01) && !(s->opt->mode & MODE_PLAY0x01)) ||
12
←
Assuming the condition is false→
   ((s->mode & MODE_RECMASK(0x02 | 0x10)) && !(s->opt->mode & MODE_RECMASK(0x02 | 0x10)))) {
13
←
Assuming the condition is false→
if (log_level >= 1) {
	slot_log(s);
	log_puts(" at ");
	log_puts(s->opt->name);
	log_puts(": mode not allowed on this sub-device\n");
}
}

/*
* setup converions layer
*/
slot_initconv(s);

/*
* start the device if not started
*/
dev_wakeup(d);
14
←
Calling 'dev_wakeup'→
18
←
Returning from 'dev_wakeup'→

/*
* adjust initial clock
*/
pos = s->delta_rem +
   (long long)s->delta * d->round +
   (long long)d->delta * s->round;
s->delta = pos / (int)d->round;
s->delta_rem = pos % d->round;
if (s->delta_rem < 0) {
19
←
Assuming field 'delta_rem' is >= 0→
20
←
Taking false branch→
s->delta_rem += d->round;
s->delta--;
}

1948#ifdef DEBUG1
if (log_level >= 2) {
21
←
Assuming 'log_level' is >= 2→
22
←
Taking true branch→
slot_log(s);
log_puts(": attached at ");
log_puti(s->delta);
log_puts(" + ");
log_puti(s->delta_rem);
log_puts("/");
log_puti(s->round);
log_puts("\n");
}
1959#endif

/*
* We dont check whether the device is dying,
* because dev_xxx() functions are supposed to
* work (i.e., not to crash)
*/

s->next = d->slot_list;
d->slot_list = s;
if (s->mode & MODE_PLAY0x01) {
23
←
Assuming the condition is true→
24
←
Taking true branch→
s->mix.vol = MIDI_TO_ADATA(s->vol)(aparams_ctltovol[s->vol] << (16 - 16));
dev_mix_adjvol(d);
25
←
Calling 'dev_mix_adjvol'→
}
1973}

1975/*
* if MMC is enabled, and try to attach all slots synchronously, else
* simply attach the slot
*/
1979void
1980slot_ready(struct slot *s)
1981{
/*
* device may be disconnected, and if so we're called from
* slot->ops->exit() on a closed device
*/
if (s->opt->dev->pstate == DEV_CFG0)
7
←
Assuming field 'pstate' is not equal to DEV_CFG→
8
←
Taking false branch→
return;
if (s->opt->mtc == NULL((void*)0)) {
9
←
Assuming field 'mtc' is equal to NULL→
10
←
Taking true branch→
slot_attach(s);
11
←
Calling 'slot_attach'→
s->pstate = SLOT_RUN3;
} else
mtc_trigger(s->opt->mtc);
1993}

1995/*
* setup buffers & conversion layers, prepare the slot to receive data
* (for playback) or start (recording).
*/
1999void
2000slot_start(struct slot *s)
2001{
struct dev *d = s->opt->dev;
2003#ifdef DEBUG1
if (s->pstate != SLOT_INIT0) {
slot_log(s);
log_puts(": slot_start: wrong state\n");
panic();
}
if (s->mode & MODE_PLAY0x01) {
if (log_level >= 3) {
	slot_log(s);
	log_puts(": playing ");
	aparams_log(&s->par);
	log_puts(" -> ");
	aparams_log(&d->par);
	log_puts("\n");
}
}
if (s->mode & MODE_RECMASK(0x02 | 0x10)) {
if (log_level >= 3) {
	slot_log(s);
	log_puts(": recording ");
	aparams_log(&s->par);
	log_puts(" <- ");
	aparams_log(&d->par);
	log_puts("\n");
}
}
2029#endif
slot_allocbufs(s);

if (s->mode & MODE_RECMASK(0x02 | 0x10)) {
/*
 * N-th recorded block is the N-th played block
 */
s->sub.prime = d->bufsz / d->round;
}
s->skip = 0;

/*
* get the current position, the origin is when the first sample
* played and/or recorded
*/
s->delta = -(long long)d->bufsz * s->round / d->round;
s->delta_rem = 0;

if (s->mode & MODE_PLAY0x01) {
s->pstate = SLOT_START1;
} else {
s->pstate = SLOT_READY2;
slot_ready(s);
}
2053}

2055/*
* stop playback and recording, and free conversion layers
*/
2058void
2059slot_detach(struct slot *s)
2060{
struct slot **ps;
struct dev *d = s->opt->dev;
long long pos;

for (ps = &d->slot_list; *ps != s; ps = &(*ps)->next) {
2066#ifdef DEBUG1
if (*ps == NULL((void*)0)) {
	slot_log(s);
	log_puts(": can't detach, not on list\n");
	panic();
}
2072#endif
}
*ps = s->next;

/*
* adjust clock, go back d->delta ticks so that slot_attach()
* could be called with the resulting state
*/
pos = s->delta_rem +
   (long long)s->delta * d->round -
   (long long)d->delta * s->round;
s->delta = pos / (int)d->round;
s->delta_rem = pos % d->round;
if (s->delta_rem < 0) {
s->delta_rem += d->round;
s->delta--;
}

2090#ifdef DEBUG1
if (log_level >= 2) {
slot_log(s);
log_puts(": detached at ");
log_puti(s->delta);
log_puts(" + ");
log_puti(s->delta_rem);
log_puts("/");
log_puti(d->round);
log_puts("\n");
}
2101#endif
if (s->mode & MODE_PLAY0x01)
dev_mix_adjvol(d);

if (s->mode & MODE_RECMASK(0x02 | 0x10)) {
if (s->sub.encbuf) {
	xfree(s->sub.encbuf);
	s->sub.encbuf = NULL((void*)0);
}
if (s->sub.resampbuf) {
	xfree(s->sub.resampbuf);
	s->sub.resampbuf = NULL((void*)0);
}
}

if (s->mode & MODE_PLAY0x01) {
if (s->mix.decbuf) {
	xfree(s->mix.decbuf);
	s->mix.decbuf = NULL((void*)0);
}
if (s->mix.resampbuf) {
	xfree(s->mix.resampbuf);
	s->mix.resampbuf = NULL((void*)0);
}
}
2126}

2128/*
* put the slot in stopping state (draining play buffers) or
* stop & detach if no data to drain.
*/
2132void
2133slot_stop(struct slot *s, int drain)
2134{
2135#ifdef DEBUG1
if (log_level >= 3) {
slot_log(s);
log_puts(": stopping\n");
}
2140#endif
if (s->pstate == SLOT_START1) {
/*
 * If in rec-only mode, we're already in the READY or
 * RUN states. We're here because the play buffer was
 * not full enough, try to start so it's drained.
 */
s->pstate = SLOT_READY2;
slot_ready(s);
}

if (s->pstate == SLOT_RUN3) {
if ((s->mode & MODE_PLAY0x01) && drain) {
	/*
	 * Don't detach, dev_cycle() will do it for us
	 * when the buffer is drained.
	 */
	s->pstate = SLOT_STOP4;
	return;
}
slot_detach(s);
} else if (s->pstate == SLOT_STOP4) {
slot_detach(s);
} else {
2164#ifdef DEBUG1
if (log_level >= 3) {
	slot_log(s);
	log_puts(": not drained (blocked by mmc)\n");
}
2169#endif
}

s->pstate = SLOT_INIT0;
s->ops->eof(s->arg);
slot_freebufs(s);
2175}

2177void
2178slot_skip_update(struct slot *s)
2179{
int skip;

skip = slot_skip(s);
while (skip > 0) {
2184#ifdef DEBUG1
if (log_level >= 4) {
	slot_log(s);
	log_puts(": catching skipped block\n");
}
2189#endif
if (s->mode & MODE_RECMASK(0x02 | 0x10))
	s->ops->flush(s->arg);
if (s->mode & MODE_PLAY0x01)
	s->ops->fill(s->arg);
skip--;
}
2196}

2198/*
* notify the slot that we just wrote in the play buffer, must be called
* after each write
*/
2202void
2203slot_write(struct slot *s)
2204{
if (s->pstate == SLOT_START1 && s->mix.buf.used == s->mix.buf.len) {
1
Assuming field 'pstate' is equal to SLOT_START→
2
←
Assuming field 'used' is equal to field 'len'→
3
←
Taking true branch→
2206#ifdef DEBUG1
if (log_level >= 4) {
4
←
Assuming 'log_level' is < 4→
5
←
Taking false branch→
	slot_log(s);
	log_puts(": switching to READY state\n");
}
2211#endif
s->pstate = SLOT_READY2;
slot_ready(s);
6
←
Calling 'slot_ready'→
}
slot_skip_update(s);
2216}

2218/*
* notify the slot that we freed some space in the rec buffer
*/
2221void
2222slot_read(struct slot *s)
2223{
slot_skip_update(s);
2225}

2227/*
* allocate at control slot
*/
2230struct ctlslot *
2231ctlslot_new(struct opt *o, struct ctlops *ops, void *arg)
2232{
struct ctlslot *s;
struct ctl *c;
int i;

i = 0;
for (;;) {
if (i == DEV_NCTLSLOT8)
	return NULL((void*)0);
s = ctlslot_array + i;
if (s->ops == NULL((void*)0))
	break;
i++;
}
s->opt = o;
s->self = 1 << i;
if (!opt_ref(o))
return NULL((void*)0);
s->ops = ops;
s->arg = arg;
for (c = ctl_list; c != NULL((void*)0); c = c->next) {
if (!ctlslot_visible(s, c))
	continue;
c->refs_mask |= s->self;
}
return s;
2258}

2260/*
* free control slot
*/
2263void
2264ctlslot_del(struct ctlslot *s)
2265{
struct ctl *c, **pc;

pc = &ctl_list;
while ((c = *pc) != NULL((void*)0)) {
c->refs_mask &= ~s->self;
if (c->refs_mask == 0) {
	*pc = c->next;
	xfree(c);
} else
	pc = &c->next;
}
s->ops = NULL((void*)0);
opt_unref(s->opt);
2279}

2281int
2282ctlslot_visible(struct ctlslot *s, struct ctl *c)
2283{
if (s->opt == NULL((void*)0))
return 1;
switch (c->scope) {
case CTL_HW0:
case CTL_DEV_MASTER1:
return (s->opt->dev == c->u.any.arg0);
case CTL_OPT_DEV2:
return (s->opt == c->u.any.arg0);
case CTL_SLOT_LEVEL3:
return (s->opt->dev == c->u.slot_level.slot->opt->dev);
default:
return 0;
}
2297}

2299struct ctl *
2300ctlslot_lookup(struct ctlslot *s, int addr)
2301{
struct ctl *c;

c = ctl_list;
while (1) {
if (c == NULL((void*)0))
	return NULL((void*)0);
if (c->type != CTL_NONE0 && c->addr == addr)
	break;
c = c->next;
}
if (!ctlslot_visible(s, c))
return NULL((void*)0);
return c;
2315}

2317void
2318ctlslot_update(struct ctlslot *s)
2319{
struct ctl *c;
unsigned int refs_mask;

for (c = ctl_list; c != NULL((void*)0); c = c->next) {
if (c->type == CTL_NONE0)
	continue;
refs_mask = ctlslot_visible(s, c) ? s->self : 0;

/* nothing to do if no visibility change */
if (((c->refs_mask & s->self) ^ refs_mask) == 0)
	continue;
/* if control becomes visble */
if (refs_mask)
	c->refs_mask |= s->self;
/* if control is hidden */
c->desc_mask |= s->self;
}
2337}

2339void
2340ctl_node_log(struct ctl_node *c)
2341{
log_puts(c->name);
if (c->unit >= 0)
log_putu(c->unit);
2345}

2347void
2348ctl_log(struct ctl *c)
2349{
if (c->group[0] != 0) {
log_puts(c->group);
log_puts("/");
}
ctl_node_log(&c->node0);
log_puts(".");
log_puts(c->func);
log_puts("=");
switch (c->type) {
case CTL_NONE0:
log_puts("none");
break;
case CTL_NUM2:
case CTL_SW3:
log_putu(c->curval);
break;
case CTL_VEC4:
case CTL_LIST5:
case CTL_SEL6:
ctl_node_log(&c->node1);
log_puts(":");
log_putu(c->curval);
}
log_puts(" at ");
log_putu(c->addr);
log_puts(" -> ");
switch (c->scope) {
case CTL_HW0:
log_puts("hw:");
log_puts(c->u.hw.dev->name);
log_puts("/");
log_putu(c->u.hw.addr);
break;
case CTL_DEV_MASTER1:
log_puts("dev_master:");
log_puts(c->u.dev_master.dev->name);
break;
case CTL_SLOT_LEVEL3:
log_puts("slot_level:");
log_puts(c->u.slot_level.slot->name);
log_putu(c->u.slot_level.slot->unit);
break;
case CTL_OPT_DEV2:
log_puts("opt_dev:");
log_puts(c->u.opt_dev.opt->name);
log_puts("/");
log_puts(c->u.opt_dev.dev->name);
break;
default:
log_puts("unknown");
}
2401}

2403int
2404ctl_setval(struct ctl *c, int val)
2405{
if (c->curval == val) {
if (log_level >= 3) {
	ctl_log(c);
	log_puts(": already set\n");
}
return 1;
}
if (val < 0 || val > c->maxval) {
if (log_level >= 3) {
	log_putu(val);
	log_puts(": ctl val out of bounds\n");
}
return 0;
}

switch (c->scope) {
case CTL_HW0:
if (log_level >= 3) {
	ctl_log(c);
	log_puts(": marked as dirty\n");
}
c->curval = val;
c->dirty = 1;
return dev_ref(c->u.hw.dev);
case CTL_DEV_MASTER1:
if (!c->u.dev_master.dev->master_enabled)
	return 1;
dev_master(c->u.dev_master.dev, val);
dev_midi_master(c->u.dev_master.dev);
c->val_mask = ~0U;
c->curval = val;
return 1;
case CTL_SLOT_LEVEL3:
slot_setvol(c->u.slot_level.slot, val);
// XXX change dev_midi_vol() into slot_midi_vol()
dev_midi_vol(c->u.slot_level.slot->opt->dev, c->u.slot_level.slot);
c->val_mask = ~0U;
c->curval = val;
return 1;
case CTL_OPT_DEV2:
c->u.opt_dev.opt->alt_first = c->u.opt_dev.dev;
opt_setdev(c->u.opt_dev.opt, c->u.opt_dev.dev);
return 1;
default:
if (log_level >= 2) {
	ctl_log(c);
	log_puts(": not writable\n");
}
return 1;
}
2456}

2458/*
* add a ctl
*/
2461struct ctl *
2462ctl_new(int scope, void *arg0, void *arg1,
  int type, char *gstr,
  char *str0, int unit0, char *func,
  char *str1, int unit1, int maxval, int val)
2466{
struct ctl *c, **pc;
struct ctlslot *s;
int addr;
int i;

/*
* find the smallest unused addr number and
* the last position in the list
*/
addr = 0;
for (pc = &ctl_list; (c = *pc) != NULL((void*)0); pc = &c->next) {
if (c->addr > addr)
	addr = c->addr;
}
addr++;

c = xmalloc(sizeof(struct ctl));
c->type = type;
strlcpy(c->func, func, CTL_NAMEMAX16);
strlcpy(c->group, gstr, CTL_NAMEMAX16);
strlcpy(c->node0.name, str0, CTL_NAMEMAX16);
c->node0.unit = unit0;
if (c->type == CTL_VEC4 || c->type == CTL_LIST5 || c->type == CTL_SEL6) {
strlcpy(c->node1.name, str1, CTL_NAMEMAX16);
c->node1.unit = unit1;
} else
memset(&c->node1, 0, sizeof(struct ctl_node));
c->scope = scope;
c->u.any.arg0 = arg0;
switch (scope) {
case CTL_HW0:
c->u.hw.addr = *(unsigned int *)arg1;
break;
case CTL_OPT_DEV2:
c->u.any.arg1 = arg1;
break;
default:
c->u.any.arg1 = NULL((void*)0);
}
c->addr = addr;
c->maxval = maxval;
c->val_mask = ~0;
c->desc_mask = ~0;
c->curval = val;
c->dirty = 0;
c->refs_mask = CTL_DEVMASK(1 << 31);
for (s = ctlslot_array, i = 0; i < DEV_NCTLSLOT8; i++, s++) {
if (s->ops == NULL((void*)0))
	continue;
if (ctlslot_visible(s, c))
	c->refs_mask |= 1 << i;
}
c->next = *pc;
*pc = c;
2521#ifdef DEBUG1
if (log_level >= 2) {
ctl_log(c);
log_puts(": added\n");
}
2526#endif
return c;
2528}

2530void
2531ctl_update(struct ctl *c)
2532{
struct ctlslot *s;
unsigned int refs_mask;
int i;

for (s = ctlslot_array, i = 0; i < DEV_NCTLSLOT8; i++, s++) {
if (s->ops == NULL((void*)0))
	continue;
refs_mask = ctlslot_visible(s, c) ? s->self : 0;

/* nothing to do if no visibility change */
if (((c->refs_mask & s->self) ^ refs_mask) == 0)
	continue;
/* if control becomes visble */
if (refs_mask)
	c->refs_mask |= s->self;
/* if control is hidden */
c->desc_mask |= s->self;
}
2551}

2553int
2554ctl_match(struct ctl *c, int scope, void *arg0, void *arg1)
2555{
if (c->type == CTL_NONE0 || c->scope != scope || c->u.any.arg0 != arg0)
return 0;
if (arg0 != NULL((void*)0) && c->u.any.arg0 != arg0)
return 0;
switch (scope) {
case CTL_HW0:
if (arg1 != NULL((void*)0) && c->u.hw.addr != *(unsigned int *)arg1)
	return 0;
break;
case CTL_OPT_DEV2:
if (arg1 != NULL((void*)0) && c->u.any.arg1 != arg1)
	return 0;
break;
}
return 1;
2571}

2573struct ctl *
2574ctl_find(int scope, void *arg0, void *arg1)
2575{
struct ctl *c;

for (c = ctl_list; c != NULL((void*)0); c = c->next) {
if (ctl_match(c, scope, arg0, arg1))
	return c;
}
return NULL((void*)0);
2583}

2585int
2586ctl_onval(int scope, void *arg0, void *arg1, int val)
2587{
struct ctl *c;

c = ctl_find(scope, arg0, arg1);
if (c == NULL((void*)0))
return 0;
c->curval = val;
c->val_mask = ~0U;
return 1;
2596}

2598void
2599ctl_del(int scope, void *arg0, void *arg1)
2600{
struct ctl *c, **pc;

pc = &ctl_list;
for (;;) {
c = *pc;
if (c == NULL((void*)0))
	return;
if (ctl_match(c, scope, arg0, arg1)) {
2609#ifdef DEBUG1
	if (log_level >= 2) {
		ctl_log(c);
		log_puts(": removed\n");
	}
2614#endif
	c->refs_mask &= ~CTL_DEVMASK(1 << 31);
	if (c->refs_mask == 0) {
		*pc = c->next;
		xfree(c);
		continue;
	}
	c->type = CTL_NONE0;
	c->desc_mask = ~0;
}
pc = &c->next;
}
2626}

2628void
2629dev_ctlsync(struct dev *d)
2630{
struct ctl *c;
struct ctlslot *s;
int found, i;

found = 0;
for (c = ctl_list; c != NULL((void*)0); c = c->next) {
if (c->scope == CTL_HW0 &&
    c->u.hw.dev == d &&
    c->type == CTL_NUM2 &&
    strcmp(c->group, d->name) == 0 &&
    strcmp(c->node0.name, "output") == 0 &&
    strcmp(c->func, "level") == 0)
	found = 1;
}

if (d->master_enabled && found) {
if (log_level >= 2) {
	dev_log(d);
	log_puts(": software master level control disabled\n");
}
d->master_enabled = 0;
ctl_del(CTL_DEV_MASTER1, d, NULL((void*)0));
} else if (!d->master_enabled && !found) {
if (log_level >= 2) {
	dev_log(d);
	log_puts(": software master level control enabled\n");
}
d->master_enabled = 1;
ctl_new(CTL_DEV_MASTER1, d, NULL((void*)0),
    CTL_NUM2, d->name, "output", -1, "level",
    NULL((void*)0), -1, 127, d->master);
}

for (s = ctlslot_array, i = 0; i < DEV_NCTLSLOT8; i++, s++) {
if (s->ops == NULL((void*)0))
	continue;
if (s->opt->dev == d)
	s->ops->sync(s->arg);
}
2670}