xref: /freebsd/lib/libmixer/mixer.c (revision 61e21613) 
1 /*-
2  * Copyright (c) 2021 Christos Margiolis <christos@FreeBSD.org>
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a copy
5  * of this software and associated documentation files (the "Software"), to deal
6  * in the Software without restriction, including without limitation the rights
7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8  * copies of the Software, and to permit persons to whom the Software is
9  * furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20  * THE SOFTWARE.
21  */
22 
23 #include <sys/types.h>
24 #include <sys/ioctl.h>
25 #include <sys/sysctl.h>
26 
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 
34 #include "mixer.h"
35 
36 #define	BASEPATH "/dev/mixer"
37 
38 static int _mixer_readvol(struct mix_dev *);
39 
40 /*
41  * Fetch volume from the device.
42  */
43 static int
44 _mixer_readvol(struct mix_dev *dev)
45 {
46 	int v;
47 
48 	if (ioctl(dev->parent_mixer->fd, MIXER_READ(dev->devno), &v) < 0)
49 		return (-1);
50 	dev->vol.left = MIX_VOLNORM(v & 0x00ff);
51 	dev->vol.right = MIX_VOLNORM((v >> 8) & 0x00ff);
52 
53 	return (0);
54 }
55 
56 /*
57  * Open a mixer device in `/dev/mixerN`, where N is the number of the mixer.
58  * Each device maps to an actual pcm audio card, so `/dev/mixer0` is the
59  * mixer for pcm0, and so on.
60  *
61  * @param name		path to mixer device. NULL or "/dev/mixer" for the
62  *			the default mixer (i.e `hw.snd.default_unit`).
63  */
64 struct mixer *
65 mixer_open(const char *name)
66 {
67 	struct mixer *m = NULL;
68 	struct mix_dev *dp;
69 	const char *names[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
70 	int i;
71 
72 	if ((m = calloc(1, sizeof(struct mixer))) == NULL)
73 		goto fail;
74 
75 	if (name != NULL) {
76 		/* `name` does not start with "/dev/mixer". */
77 		if (strncmp(name, BASEPATH, strlen(BASEPATH)) != 0) {
78 			m->unit = -1;
79 		} else {
80 			/* `name` is "/dev/mixer" so, we'll use the default unit. */
81 			if (strncmp(name, BASEPATH, strlen(name)) == 0)
82 				goto dunit;
83 			m->unit = strtol(name + strlen(BASEPATH), NULL, 10);
84 		}
85 		(void)strlcpy(m->name, name, sizeof(m->name));
86 	} else {
87 dunit:
88 		if ((m->unit = mixer_get_dunit()) < 0)
89 			goto fail;
90 		(void)snprintf(m->name, sizeof(m->name), "/dev/mixer%d", m->unit);
91 	}
92 
93 	if ((m->fd = open(m->name, O_RDWR)) < 0)
94 		goto fail;
95 
96 	m->devmask = m->recmask = m->recsrc = 0;
97 	m->f_default = m->unit == mixer_get_dunit();
98 	m->mode = mixer_get_mode(m->unit);
99 	/* The unit number _must_ be set before the ioctl. */
100 	m->mi.dev = m->unit;
101 	m->ci.card = m->unit;
102 	if (ioctl(m->fd, SNDCTL_MIXERINFO, &m->mi) < 0) {
103 		memset(&m->mi, 0, sizeof(m->mi));
104 		strlcpy(m->mi.name, m->name, sizeof(m->mi.name));
105 	}
106 	if (ioctl(m->fd, SNDCTL_CARDINFO, &m->ci) < 0)
107 		memset(&m->ci, 0, sizeof(m->ci));
108 	if (ioctl(m->fd, SOUND_MIXER_READ_DEVMASK, &m->devmask) < 0 ||
109 	    ioctl(m->fd, SOUND_MIXER_READ_MUTE, &m->mutemask) < 0 ||
110 	    ioctl(m->fd, SOUND_MIXER_READ_RECMASK, &m->recmask) < 0 ||
111 	    ioctl(m->fd, SOUND_MIXER_READ_RECSRC, &m->recsrc) < 0)
112 		goto fail;
113 
114 	TAILQ_INIT(&m->devs);
115 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
116 		if (!MIX_ISDEV(m, i))
117 			continue;
118 		if ((dp = calloc(1, sizeof(struct mix_dev))) == NULL)
119 			goto fail;
120 		dp->parent_mixer = m;
121 		dp->devno = i;
122 		dp->nctl = 0;
123 		if (_mixer_readvol(dp) < 0)
124 			goto fail;
125 		(void)strlcpy(dp->name, names[i], sizeof(dp->name));
126 		TAILQ_INIT(&dp->ctls);
127 		TAILQ_INSERT_TAIL(&m->devs, dp, devs);
128 		m->ndev++;
129 	}
130 
131 	/* The default device is always "vol". */
132 	m->dev = TAILQ_FIRST(&m->devs);
133 
134 	return (m);
135 fail:
136 	if (m != NULL)
137 		(void)mixer_close(m);
138 
139 	return (NULL);
140 }
141 
142 /*
143  * Free resources and close the mixer.
144  */
145 int
146 mixer_close(struct mixer *m)
147 {
148 	struct mix_dev *dp;
149 	int r;
150 
151 	r = close(m->fd);
152 	while (!TAILQ_EMPTY(&m->devs)) {
153 		dp = TAILQ_FIRST(&m->devs);
154 		TAILQ_REMOVE(&m->devs, dp, devs);
155 		while (!TAILQ_EMPTY(&dp->ctls))
156 			(void)mixer_remove_ctl(TAILQ_FIRST(&dp->ctls));
157 		free(dp);
158 	}
159 	free(m);
160 
161 	return (r);
162 }
163 
164 /*
165  * Select a mixer device. The mixer structure keeps a list of all the devices
166  * the mixer has, but only one can be manipulated at a time -- this is what
167  * the `dev` in the mixer structure field is for. Each time a device is to be
168  * manipulated, `dev` has to point to it first.
169  *
170  * The caller must manually assign the return value to `m->dev`.
171  */
172 struct mix_dev *
173 mixer_get_dev(struct mixer *m, int dev)
174 {
175 	struct mix_dev *dp;
176 
177 	if (dev < 0 || dev >= m->ndev) {
178 		errno = ERANGE;
179 		return (NULL);
180 	}
181 	TAILQ_FOREACH(dp, &m->devs, devs) {
182 		if (dp->devno == dev)
183 			return (dp);
184 	}
185 	errno = EINVAL;
186 
187 	return (NULL);
188 }
189 
190 /*
191  * Select a device by name.
192  *
193  * @param name		device name (e.g vol, pcm, ...)
194  */
195 struct mix_dev *
196 mixer_get_dev_byname(struct mixer *m, const char *name)
197 {
198 	struct mix_dev *dp;
199 
200 	TAILQ_FOREACH(dp, &m->devs, devs) {
201 		if (!strncmp(dp->name, name, sizeof(dp->name)))
202 			return (dp);
203 	}
204 	errno = EINVAL;
205 
206 	return (NULL);
207 }
208 
209 /*
210  * Add a mixer control to a device.
211  */
212 int
213 mixer_add_ctl(struct mix_dev *parent_dev, int id, const char *name,
214     int (*mod)(struct mix_dev *, void *),
215     int (*print)(struct mix_dev *, void *))
216 {
217 	struct mix_dev *dp;
218 	mix_ctl_t *ctl, *cp;
219 
220 	/* XXX: should we accept NULL name? */
221 	if (parent_dev == NULL) {
222 		errno = EINVAL;
223 		return (-1);
224 	}
225 	if ((ctl = calloc(1, sizeof(mix_ctl_t))) == NULL)
226 		return (-1);
227 	ctl->parent_dev = parent_dev;
228 	ctl->id = id;
229 	if (name != NULL)
230 		(void)strlcpy(ctl->name, name, sizeof(ctl->name));
231 	ctl->mod = mod;
232 	ctl->print = print;
233 	dp = ctl->parent_dev;
234 	/* Make sure the same ID or name doesn't exist already. */
235 	TAILQ_FOREACH(cp, &dp->ctls, ctls) {
236 		if (!strncmp(cp->name, name, sizeof(cp->name)) || cp->id == id) {
237 			errno = EINVAL;
238 			return (-1);
239 		}
240 	}
241 	TAILQ_INSERT_TAIL(&dp->ctls, ctl, ctls);
242 	dp->nctl++;
243 
244 	return (0);
245 }
246 
247 /*
248  * Same as `mixer_add_ctl`.
249  */
250 int
251 mixer_add_ctl_s(mix_ctl_t *ctl)
252 {
253 	if (ctl == NULL)
254 		return (-1);
255 
256 	return (mixer_add_ctl(ctl->parent_dev, ctl->id, ctl->name,
257 	    ctl->mod, ctl->print));
258 }
259 
260 /*
261  * Remove a mixer control from a device.
262  */
263 int
264 mixer_remove_ctl(mix_ctl_t *ctl)
265 {
266 	struct mix_dev *p;
267 
268 	if (ctl == NULL) {
269 		errno = EINVAL;
270 		return (-1);
271 	}
272 	p = ctl->parent_dev;
273 	if (!TAILQ_EMPTY(&p->ctls)) {
274 		TAILQ_REMOVE(&p->ctls, ctl, ctls);
275 		free(ctl);
276 	}
277 
278 	return (0);
279 }
280 
281 /*
282  * Get a mixer control by id.
283  */
284 mix_ctl_t *
285 mixer_get_ctl(struct mix_dev *d, int id)
286 {
287 	mix_ctl_t *cp;
288 
289 	TAILQ_FOREACH(cp, &d->ctls, ctls) {
290 		if (cp->id == id)
291 			return (cp);
292 	}
293 	errno = EINVAL;
294 
295 	return (NULL);
296 }
297 
298 /*
299  * Get a mixer control by name.
300  */
301 mix_ctl_t *
302 mixer_get_ctl_byname(struct mix_dev *d, const char *name)
303 {
304 	mix_ctl_t *cp;
305 
306 	TAILQ_FOREACH(cp, &d->ctls, ctls) {
307 		if (!strncmp(cp->name, name, sizeof(cp->name)))
308 			return (cp);
309 	}
310 	errno = EINVAL;
311 
312 	return (NULL);
313 }
314 
315 /*
316  * Change the mixer's left and right volume. The allowed volume values are
317  * between MIX_VOLMIN and MIX_VOLMAX. The `ioctl` for volume change requires
318  * an integer value between 0 and 100 stored as `lvol | rvol << 8` --  for
319  * that reason, we de-normalize the 32-bit float volume value, before
320  * we pass it to the `ioctl`.
321  *
322  * Volume clumping should be done by the caller.
323  */
324 int
325 mixer_set_vol(struct mixer *m, mix_volume_t vol)
326 {
327 	int v;
328 
329 	if (vol.left < MIX_VOLMIN || vol.left > MIX_VOLMAX ||
330 	    vol.right < MIX_VOLMIN || vol.right > MIX_VOLMAX) {
331 		errno = ERANGE;
332 		return (-1);
333 	}
334 	v = MIX_VOLDENORM(vol.left) | MIX_VOLDENORM(vol.right) << 8;
335 	if (ioctl(m->fd, MIXER_WRITE(m->dev->devno), &v) < 0)
336 		return (-1);
337 	if (_mixer_readvol(m->dev) < 0)
338 		return (-1);
339 
340 	return (0);
341 }
342 
343 /*
344  * Manipulate a device's mute.
345  *
346  * @param opt		MIX_MUTE mute device
347  *			MIX_UNMUTE unmute device
348  *			MIX_TOGGLEMUTE toggle device's mute
349  */
350 int
351 mixer_set_mute(struct mixer *m, int opt)
352 {
353 	switch (opt) {
354 	case MIX_MUTE:
355 		m->mutemask |= (1 << m->dev->devno);
356 		break;
357 	case MIX_UNMUTE:
358 		m->mutemask &= ~(1 << m->dev->devno);
359 		break;
360 	case MIX_TOGGLEMUTE:
361 		m->mutemask ^= (1 << m->dev->devno);
362 		break;
363 	default:
364 		errno = EINVAL;
365 		return (-1);
366 	}
367 	if (ioctl(m->fd, SOUND_MIXER_WRITE_MUTE, &m->mutemask) < 0)
368 		return (-1);
369 	if (ioctl(m->fd, SOUND_MIXER_READ_MUTE, &m->mutemask) < 0)
370 		return (-1);
371 
372 	return 0;
373 }
374 
375 /*
376  * Modify a recording device. The selected device has to be a recording device,
377  * otherwise the function will fail.
378  *
379  * @param opt		MIX_ADDRECSRC add device to recording sources
380  *			MIX_REMOVERECSRC remove device from recording sources
381  *			MIX_SETRECSRC set device as the only recording source
382  *			MIX_TOGGLERECSRC toggle device from recording sources
383  */
384 int
385 mixer_mod_recsrc(struct mixer *m, int opt)
386 {
387 	if (!m->recmask || !MIX_ISREC(m, m->dev->devno)) {
388 		errno = ENODEV;
389 		return (-1);
390 	}
391 	switch (opt) {
392 	case MIX_ADDRECSRC:
393 		m->recsrc |= (1 << m->dev->devno);
394 		break;
395 	case MIX_REMOVERECSRC:
396 		m->recsrc &= ~(1 << m->dev->devno);
397 		break;
398 	case MIX_SETRECSRC:
399 		m->recsrc = (1 << m->dev->devno);
400 		break;
401 	case MIX_TOGGLERECSRC:
402 		m->recsrc ^= (1 << m->dev->devno);
403 		break;
404 	default:
405 		errno = EINVAL;
406 		return (-1);
407 	}
408 	if (ioctl(m->fd, SOUND_MIXER_WRITE_RECSRC, &m->recsrc) < 0)
409 		return (-1);
410 	if (ioctl(m->fd, SOUND_MIXER_READ_RECSRC, &m->recsrc) < 0)
411 		return (-1);
412 
413 	return (0);
414 }
415 
416 /*
417  * Get default audio card's number. This is used to open the default mixer
418  * and set the mixer structure's `f_default` flag.
419  */
420 int
421 mixer_get_dunit(void)
422 {
423 	size_t size;
424 	int unit;
425 
426 	size = sizeof(int);
427 	if (sysctlbyname("hw.snd.default_unit", &unit, &size, NULL, 0) < 0)
428 		return (-1);
429 
430 	return (unit);
431 }
432 
433 /*
434  * Change the default audio card. This is normally _not_ a mixer feature, but
435  * it's useful to have, so the caller can avoid having to manually use
436  * the sysctl API.
437  *
438  * @param unit		the audio card number (e.g pcm0, pcm1, ...).
439  */
440 int
441 mixer_set_dunit(struct mixer *m, int unit)
442 {
443 	size_t size;
444 
445 	size = sizeof(int);
446 	if (sysctlbyname("hw.snd.default_unit", NULL, 0, &unit, size) < 0)
447 		return (-1);
448 	/* XXX: how will other mixers get updated? */
449 	m->f_default = m->unit == unit;
450 
451 	return (0);
452 }
453 
454 /*
455  * Get sound device mode (none, play, rec, play+rec). Userland programs can
456  * use the MIX_MODE_* flags to determine the mode of the device.
457  */
458 int
459 mixer_get_mode(int unit)
460 {
461 	char buf[64];
462 	size_t size;
463 	unsigned int mode;
464 
465 	(void)snprintf(buf, sizeof(buf), "dev.pcm.%d.mode", unit);
466 	size = sizeof(unsigned int);
467 	if (sysctlbyname(buf, &mode, &size, NULL, 0) < 0)
468 		return (0);
469 
470 	return (mode);
471 }
472 
473 /*
474  * Get the total number of mixers in the system.
475  */
476 int
477 mixer_get_nmixers(void)
478 {
479 	struct mixer *m;
480 	oss_sysinfo si;
481 
482 	/*
483 	 * Open a dummy mixer because we need the `fd` field for the
484 	 * `ioctl` to work.
485 	 */
486 	if ((m = mixer_open(NULL)) == NULL)
487 		return (-1);
488 	if (ioctl(m->fd, OSS_SYSINFO, &si) < 0) {
489 		(void)mixer_close(m);
490 		return (-1);
491 	}
492 	(void)mixer_close(m);
493 
494 	return (si.nummixers);
495 }
496