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