Lines Matching defs:*
2 * \file mixer/mixer.c
3 * \brief Mixer Interface
4 * \author Jaroslav Kysela <perex@perex.cz>
5 * \author Abramo Bagnara <abramo@alsa-project.org>
6 * \date 2001
8 * Mixer interface is designed to access mixer elements.
9 * Callbacks may be used for event handling.
12 * Mixer Interface - main file
13 * Copyright (c) 1998/1999/2000 by Jaroslav Kysela <perex@perex.cz>
14 * Copyright (c) 2001 by Abramo Bagnara <abramo@alsa-project.org>
17 * This library is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU Lesser General Public License as
19 * published by the Free Software Foundation; either version 2.1 of
20 * the License, or (at your option) any later version.
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU Lesser General Public License for more details.
27 * You should have received a copy of the GNU Lesser General Public
28 * License along with this library; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33 /*! \page mixer Mixer interface
35 <P>Mixer interface is designed to access the abstracted mixer controls.
36 This is an abstraction layer over the hcontrol layer.
38 \section mixer_general_overview General overview
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <unistd.h>
45 #include <string.h>
46 #include <fcntl.h>
47 #include <sys/ioctl.h>
48 #include "mixer_local.h"
50 #ifndef DOC_HIDDEN
51 typedef struct _snd_mixer_slave {
52 snd_hctl_t *hctl;
53 struct list_head list;
54 } snd_mixer_slave_t;
56 #endif
58 static int snd_mixer_compare_default(const snd_mixer_elem_t *c1,
59 const snd_mixer_elem_t *c2);
63 * \brief Opens an empty mixer
64 * \param mixerp Returned mixer handle
65 * \param mode Open mode
66 * \return 0 on success otherwise a negative error code
68 int snd_mixer_open(snd_mixer_t **mixerp, int mode ATTRIBUTE_UNUSED)
70 snd_mixer_t *mixer;
71 assert(mixerp);
72 mixer = calloc(1, sizeof(*mixer));
73 if (mixer == NULL)
74 return -ENOMEM;
75 INIT_LIST_HEAD(&mixer->slaves);
76 INIT_LIST_HEAD(&mixer->classes);
77 INIT_LIST_HEAD(&mixer->elems);
78 mixer->compare = snd_mixer_compare_default;
79 *mixerp = mixer;
80 return 0;
84 * \brief Attach an HCTL element to a mixer element
85 * \param melem Mixer element
86 * \param helem HCTL element
87 * \return 0 on success otherwise a negative error code
89 * For use by mixer element class specific code.
91 int snd_mixer_elem_attach(snd_mixer_elem_t *melem,
92 snd_hctl_elem_t *helem)
94 bag_t *bag = snd_hctl_elem_get_callback_private(helem);
95 int err;
96 err = bag_add(bag, melem);
97 if (err < 0)
98 return err;
99 return bag_add(&melem->helems, helem);
103 * \brief Detach an HCTL element from a mixer element
104 * \param melem Mixer element
105 * \param helem HCTL element
106 * \return 0 on success otherwise a negative error code
108 * For use by mixer element class specific code.
110 int snd_mixer_elem_detach(snd_mixer_elem_t *melem,
111 snd_hctl_elem_t *helem)
113 bag_t *bag = snd_hctl_elem_get_callback_private(helem);
114 int err;
115 err = bag_del(bag, melem);
116 assert(err >= 0);
117 err = bag_del(&melem->helems, helem);
118 assert(err >= 0);
119 return 0;
123 * \brief Return true if a mixer element does not contain any HCTL elements
124 * \param melem Mixer element
125 * \return 0 if not empty, 1 if empty
127 * For use by mixer element class specific code.
129 int snd_mixer_elem_empty(snd_mixer_elem_t *melem)
131 return bag_empty(&melem->helems);
134 static int hctl_elem_event_handler(snd_hctl_elem_t *helem,
135 unsigned int mask)
137 bag_t *bag = snd_hctl_elem_get_callback_private(helem);
138 if (mask == SND_CTL_EVENT_MASK_REMOVE) {
139 int res = 0;
140 int err;
141 bag_iterator_t i, n;
142 bag_for_each_safe(i, n, bag) {
143 snd_mixer_elem_t *melem = bag_iterator_entry(i);
144 snd_mixer_class_t *class = melem->class;
145 err = class->event(class, mask, helem, melem);
146 if (err < 0)
147 res = err;
149 assert(bag_empty(bag));
150 bag_free(bag);
151 return res;
153 if (mask & (SND_CTL_EVENT_MASK_VALUE | SND_CTL_EVENT_MASK_INFO)) {
154 int err = 0;
155 bag_iterator_t i, n;
156 bag_for_each_safe(i, n, bag) {
157 snd_mixer_elem_t *melem = bag_iterator_entry(i);
158 snd_mixer_class_t *class = melem->class;
159 err = class->event(class, mask, helem, melem);
160 if (err < 0)
161 return err;
164 return 0;
167 static int hctl_event_handler(snd_hctl_t *hctl, unsigned int mask,
168 snd_hctl_elem_t *elem)
170 snd_mixer_t *mixer = snd_hctl_get_callback_private(hctl);
171 int res = 0;
172 if (mask & SND_CTL_EVENT_MASK_ADD) {
173 struct list_head *pos;
174 bag_t *bag;
175 int err = bag_new(&bag);
176 if (err < 0)
177 return err;
178 snd_hctl_elem_set_callback(elem, hctl_elem_event_handler);
179 snd_hctl_elem_set_callback_private(elem, bag);
180 list_for_each(pos, &mixer->classes) {
181 snd_mixer_class_t *c;
182 c = list_entry(pos, snd_mixer_class_t, list);
183 err = c->event(c, mask, elem, NULL);
184 if (err < 0)
185 res = err;
188 return res;
193 * \brief Attach an HCTL specified with the CTL device name to an opened mixer
194 * \param mixer Mixer handle
195 * \param name HCTL name (see #snd_hctl_open)
196 * \return 0 on success otherwise a negative error code
198 int snd_mixer_attach(snd_mixer_t *mixer, const char *name)
200 snd_hctl_t *hctl;
201 int err;
203 err = snd_hctl_open(&hctl, name, 0);
204 if (err < 0)
205 return err;
206 err = snd_mixer_attach_hctl(mixer, hctl);
207 if (err < 0) {
208 snd_hctl_close(hctl);
209 return err;
211 return 0;
215 * \brief Attach an HCTL to an opened mixer
216 * \param mixer Mixer handle
217 * \param hctl the HCTL to be attached
218 * \return 0 on success otherwise a negative error code
220 int snd_mixer_attach_hctl(snd_mixer_t *mixer, snd_hctl_t *hctl)
222 snd_mixer_slave_t *slave;
223 int err;
225 assert(hctl);
226 slave = calloc(1, sizeof(*slave));
227 if (slave == NULL)
228 return -ENOMEM;
229 err = snd_hctl_nonblock(hctl, 1);
230 if (err < 0) {
231 snd_hctl_close(hctl);
232 free(slave);
233 return err;
235 snd_hctl_set_callback(hctl, hctl_event_handler);
236 snd_hctl_set_callback_private(hctl, mixer);
237 slave->hctl = hctl;
238 list_add_tail(&slave->list, &mixer->slaves);
239 return 0;
243 * \brief Detach a previously attached HCTL to an opened mixer freeing all related resources
244 * \param mixer Mixer handle
245 * \param name HCTL previously attached
246 * \return 0 on success otherwise a negative error code
248 int snd_mixer_detach(snd_mixer_t *mixer, const char *name)
250 struct list_head *pos;
251 list_for_each(pos, &mixer->slaves) {
252 snd_mixer_slave_t *s;
253 s = list_entry(pos, snd_mixer_slave_t, list);
254 if (strcmp(name, snd_hctl_name(s->hctl)) == 0) {
255 snd_hctl_close(s->hctl);
256 list_del(pos);
257 free(s);
258 return 0;
261 return -ENOENT;
265 * \brief Detach a previously attached HCTL to an opened mixer freeing all related resources
266 * \param mixer Mixer handle
267 * \param hctl HCTL previously attached
268 * \return 0 on success otherwise a negative error code
270 * Note: The hctl handle is not closed!
272 int snd_mixer_detach_hctl(snd_mixer_t *mixer, snd_hctl_t *hctl)
274 struct list_head *pos;
275 list_for_each(pos, &mixer->slaves) {
276 snd_mixer_slave_t *s;
277 s = list_entry(pos, snd_mixer_slave_t, list);
278 if (hctl == s->hctl) {
279 list_del(pos);
280 free(s);
281 return 0;
284 return -ENOENT;
288 * \brief Obtain a HCTL pointer associated to given name
289 * \param mixer Mixer handle
290 * \param name HCTL previously attached
291 * \param hctl HCTL pointer
292 * \return 0 on success otherwise a negative error code
294 int snd_mixer_get_hctl(snd_mixer_t *mixer, const char *name, snd_hctl_t **hctl)
296 struct list_head *pos;
297 list_for_each(pos, &mixer->slaves) {
298 snd_mixer_slave_t *s;
299 s = list_entry(pos, snd_mixer_slave_t, list);
300 if (strcmp(name, snd_hctl_name(s->hctl)) == 0) {
301 *hctl = s->hctl;
302 return 0;
305 return -ENOENT;
308 static int snd_mixer_throw_event(snd_mixer_t *mixer, unsigned int mask,
309 snd_mixer_elem_t *elem)
311 mixer->events++;
312 if (mixer->callback)
313 return mixer->callback(mixer, mask, elem);
314 return 0;
317 static int snd_mixer_elem_throw_event(snd_mixer_elem_t *elem, unsigned int mask)
319 elem->class->mixer->events++;
320 if (elem->callback)
321 return elem->callback(elem, mask);
322 return 0;
325 static int _snd_mixer_find_elem(snd_mixer_t *mixer, snd_mixer_elem_t *elem, int *dir)
327 unsigned int l, u;
328 int c = 0;
329 int idx = -1;
330 assert(mixer && elem);
331 assert(mixer->compare);
332 l = 0;
333 u = mixer->count;
334 while (l < u) {
335 idx = (l + u) / 2;
336 c = mixer->compare(elem, mixer->pelems[idx]);
337 if (c < 0)
338 u = idx;
339 else if (c > 0)
340 l = idx + 1;
341 else
342 break;
344 *dir = c;
345 return idx;
349 * \brief Get private data associated to give mixer element
350 * \param elem Mixer element
351 * \return private data
353 * For use by mixer element class specific code.
355 void *snd_mixer_elem_get_private(const snd_mixer_elem_t *elem)
357 return elem->private_data;
361 * \brief Allocate a new mixer element
362 * \param elem Returned mixer element
363 * \param type Mixer element type
364 * \param compare_weight Mixer element compare weight
365 * \param private_data Private data
366 * \param private_free Private data free callback
367 * \return 0 on success otherwise a negative error code
369 * For use by mixer element class specific code.
371 int snd_mixer_elem_new(snd_mixer_elem_t **elem,
372 snd_mixer_elem_type_t type,
373 int compare_weight,
374 void *private_data,
375 void (*private_free)(snd_mixer_elem_t *elem))
377 snd_mixer_elem_t *melem = calloc(1, sizeof(*melem));
378 if (melem == NULL)
379 return -ENOMEM;
380 melem->type = type;
381 melem->compare_weight = compare_weight;
382 melem->private_data = private_data;
383 melem->private_free = private_free;
384 INIT_LIST_HEAD(&melem->helems);
385 *elem = melem;
386 return 0;
390 * \brief Add an element for a registered mixer element class
391 * \param elem Mixer element
392 * \param class Mixer element class
393 * \return 0 on success otherwise a negative error code
395 * For use by mixer element class specific code.
397 int snd_mixer_elem_add(snd_mixer_elem_t *elem, snd_mixer_class_t *class)
399 int dir, idx;
400 snd_mixer_t *mixer = class->mixer;
401 elem->class = class;
403 if (mixer->count == mixer->alloc) {
404 snd_mixer_elem_t **m;
405 mixer->alloc += 32;
406 m = realloc(mixer->pelems, sizeof(*m) * mixer->alloc);
407 if (!m) {
408 mixer->alloc -= 32;
409 return -ENOMEM;
411 mixer->pelems = m;
413 if (mixer->count == 0) {
414 list_add_tail(&elem->list, &mixer->elems);
415 mixer->pelems[0] = elem;
416 } else {
417 idx = _snd_mixer_find_elem(mixer, elem, &dir);
418 assert(dir != 0);
419 if (dir > 0) {
420 list_add(&elem->list, &mixer->pelems[idx]->list);
421 idx++;
422 } else {
423 list_add_tail(&elem->list, &mixer->pelems[idx]->list);
425 memmove(mixer->pelems + idx + 1,
426 mixer->pelems + idx,
427 (mixer->count - idx) * sizeof(snd_mixer_elem_t *));
428 mixer->pelems[idx] = elem;
430 mixer->count++;
431 return snd_mixer_throw_event(mixer, SND_CTL_EVENT_MASK_ADD, elem);
435 * \brief Remove a mixer element
436 * \param elem Mixer element
437 * \return 0 on success otherwise a negative error code
439 * For use by mixer element class specific code.
441 int snd_mixer_elem_remove(snd_mixer_elem_t *elem)
443 snd_mixer_t *mixer = elem->class->mixer;
444 bag_iterator_t i, n;
445 int err, idx, dir;
446 unsigned int m;
447 assert(elem);
448 assert(mixer->count);
449 idx = _snd_mixer_find_elem(mixer, elem, &dir);
450 if (dir != 0)
451 return -EINVAL;
452 bag_for_each_safe(i, n, &elem->helems) {
453 snd_hctl_elem_t *helem = bag_iterator_entry(i);
454 snd_mixer_elem_detach(elem, helem);
456 err = snd_mixer_elem_throw_event(elem, SND_CTL_EVENT_MASK_REMOVE);
457 list_del(&elem->list);
458 snd_mixer_elem_free(elem);
459 mixer->count--;
460 m = mixer->count - idx;
461 if (m > 0)
462 memmove(mixer->pelems + idx,
463 mixer->pelems + idx + 1,
464 m * sizeof(snd_mixer_elem_t *));
465 return err;
469 * \brief Free a mixer element
470 * \param elem Mixer element
471 * \return 0 on success otherwise a negative error code
473 * For use by mixer element class specific code.
475 void snd_mixer_elem_free(snd_mixer_elem_t *elem)
477 if (elem->private_free)
478 elem->private_free(elem);
479 free(elem);
483 * \brief Mixer element informations are changed
484 * \param elem Mixer element
485 * \return 0 on success otherwise a negative error code
487 * For use by mixer element class specific code.
489 int snd_mixer_elem_info(snd_mixer_elem_t *elem)
491 return snd_mixer_elem_throw_event(elem, SND_CTL_EVENT_MASK_INFO);
495 * \brief Mixer element values is changed
496 * \param elem Mixer element
497 * \return 0 on success otherwise a negative error code
499 * For use by mixer element class specific code.
501 int snd_mixer_elem_value(snd_mixer_elem_t *elem)
503 return snd_mixer_elem_throw_event(elem, SND_CTL_EVENT_MASK_VALUE);
507 * \brief Register mixer element class
508 * \param class Mixer element class
509 * \param mixer Mixer handle
510 * \return 0 on success otherwise a negative error code
512 * For use by mixer element class specific code.
514 int snd_mixer_class_register(snd_mixer_class_t *class, snd_mixer_t *mixer)
516 struct list_head *pos;
517 class->mixer = mixer;
518 list_add_tail(&class->list, &mixer->classes);
519 if (!class->event)
520 return 0;
521 list_for_each(pos, &mixer->slaves) {
522 int err;
523 snd_mixer_slave_t *slave;
524 snd_hctl_elem_t *elem;
525 slave = list_entry(pos, snd_mixer_slave_t, list);
526 elem = snd_hctl_first_elem(slave->hctl);
527 while (elem) {
528 err = class->event(class, SND_CTL_EVENT_MASK_ADD, elem, NULL);
529 if (err < 0)
530 return err;
531 elem = snd_hctl_elem_next(elem);
534 return 0;
538 * \brief Unregister mixer element class and remove all its elements
539 * \param class Mixer element class
540 * \return 0 on success otherwise a negative error code
542 * Note that the class structure is also deallocated!
544 int snd_mixer_class_unregister(snd_mixer_class_t *class)
546 unsigned int k;
547 snd_mixer_elem_t *e;
548 snd_mixer_t *mixer = class->mixer;
549 for (k = mixer->count; k > 0; k--) {
550 e = mixer->pelems[k-1];
551 if (e->class == class)
552 snd_mixer_elem_remove(e);
554 if (class->private_free)
555 class->private_free(class);
556 list_del(&class->list);
557 free(class);
558 return 0;
562 * \brief Load a mixer elements
563 * \param mixer Mixer handle
564 * \return 0 on success otherwise a negative error code
566 int snd_mixer_load(snd_mixer_t *mixer)
568 struct list_head *pos;
569 list_for_each(pos, &mixer->slaves) {
570 int err;
571 snd_mixer_slave_t *s;
572 s = list_entry(pos, snd_mixer_slave_t, list);
573 err = snd_hctl_load(s->hctl);
574 if (err < 0)
575 return err;
577 return 0;
581 * \brief Unload all mixer elements and free all related resources
582 * \param mixer Mixer handle
584 void snd_mixer_free(snd_mixer_t *mixer)
586 struct list_head *pos;
587 list_for_each(pos, &mixer->slaves) {
588 snd_mixer_slave_t *s;
589 s = list_entry(pos, snd_mixer_slave_t, list);
590 snd_hctl_free(s->hctl);
595 * \brief Close a mixer and free all related resources
596 * \param mixer Mixer handle
597 * \return 0 on success otherwise a negative error code
599 int snd_mixer_close(snd_mixer_t *mixer)
601 int res = 0;
602 assert(mixer);
603 while (!list_empty(&mixer->classes)) {
604 snd_mixer_class_t *c;
605 c = list_entry(mixer->classes.next, snd_mixer_class_t, list);
606 snd_mixer_class_unregister(c);
608 assert(list_empty(&mixer->elems));
609 assert(mixer->count == 0);
610 free(mixer->pelems);
611 mixer->pelems = NULL;
612 while (!list_empty(&mixer->slaves)) {
613 int err;
614 snd_mixer_slave_t *s;
615 s = list_entry(mixer->slaves.next, snd_mixer_slave_t, list);
616 err = snd_hctl_close(s->hctl);
617 if (err < 0)
618 res = err;
619 list_del(&s->list);
620 free(s);
622 free(mixer);
623 return res;
626 static int snd_mixer_compare_default(const snd_mixer_elem_t *c1,
627 const snd_mixer_elem_t *c2)
629 int d = c1->compare_weight - c2->compare_weight;
630 if (d)
631 return d;
632 assert(c1->class && c1->class->compare);
633 assert(c2->class && c2->class->compare);
634 assert(c1->class == c2->class);
635 return c1->class->compare(c1, c2);
638 static int mixer_compare(const void *a, const void *b)
640 snd_mixer_t *mixer;
642 mixer = (*((const snd_mixer_elem_t * const *)a))->class->mixer;
643 return mixer->compare(*(const snd_mixer_elem_t * const *)a, *(const snd_mixer_elem_t * const *)b);
646 static int snd_mixer_sort(snd_mixer_t *mixer)
648 unsigned int k;
649 assert(mixer);
650 assert(mixer->compare);
651 INIT_LIST_HEAD(&mixer->elems);
652 qsort(mixer->pelems, mixer->count, sizeof(snd_mixer_elem_t *), mixer_compare);
653 for (k = 0; k < mixer->count; k++)
654 list_add_tail(&mixer->pelems[k]->list, &mixer->elems);
655 return 0;
659 * \brief Change mixer compare function and reorder elements
660 * \param mixer Mixer handle
661 * \param compare Element compare function
662 * \return 0 on success otherwise a negative error code
664 int snd_mixer_set_compare(snd_mixer_t *mixer, snd_mixer_compare_t compare)
666 snd_mixer_compare_t compare_old;
667 int err;
669 assert(mixer);
670 compare_old = mixer->compare;
671 mixer->compare = compare == NULL ? snd_mixer_compare_default : compare;
672 if ((err = snd_mixer_sort(mixer)) < 0) {
673 mixer->compare = compare_old;
674 return err;
676 return 0;
680 * \brief get count of poll descriptors for mixer handle
681 * \param mixer Mixer handle
682 * \return count of poll descriptors
684 int snd_mixer_poll_descriptors_count(snd_mixer_t *mixer)
686 struct list_head *pos;
687 unsigned int c = 0;
688 assert(mixer);
689 list_for_each(pos, &mixer->slaves) {
690 snd_mixer_slave_t *s;
691 int n;
692 s = list_entry(pos, snd_mixer_slave_t, list);
693 n = snd_hctl_poll_descriptors_count(s->hctl);
694 if (n < 0)
695 return n;
696 c += n;
698 return c;
702 * \brief get poll descriptors
703 * \param mixer Mixer handle
704 * \param pfds array of poll descriptors
705 * \param space space in the poll descriptor array
706 * \return count of filled descriptors
708 int snd_mixer_poll_descriptors(snd_mixer_t *mixer, struct pollfd *pfds, unsigned int space)
710 struct list_head *pos;
711 unsigned int count = 0;
712 assert(mixer);
713 list_for_each(pos, &mixer->slaves) {
714 snd_mixer_slave_t *s;
715 int n;
716 s = list_entry(pos, snd_mixer_slave_t, list);
717 n = snd_hctl_poll_descriptors(s->hctl, pfds, space);
718 if (n < 0)
719 return n;
720 if (space >= (unsigned int) n) {
721 count += n;
722 space -= n;
723 pfds += n;
724 } else
725 space = 0;
727 return count;
731 * \brief get returned events from poll descriptors
732 * \param mixer Mixer handle
733 * \param pfds array of poll descriptors
734 * \param nfds count of poll descriptors
735 * \param revents returned events
736 * \return zero if success, otherwise a negative error code
738 int snd_mixer_poll_descriptors_revents(snd_mixer_t *mixer, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
740 unsigned int idx;
741 unsigned short res;
742 assert(mixer && pfds && revents);
743 if (nfds == 0)
744 return -EINVAL;
745 res = 0;
746 for (idx = 0; idx < nfds; idx++)
747 res |= pfds->revents & (POLLIN|POLLERR|POLLNVAL);
748 *revents = res;
749 return 0;
753 * \brief Wait for a mixer to become ready (i.e. at least one event pending)
754 * \param mixer Mixer handle
755 * \param timeout maximum time in milliseconds to wait
756 * \return 0 otherwise a negative error code on failure
758 int snd_mixer_wait(snd_mixer_t *mixer, int timeout)
760 struct pollfd spfds[16];
761 struct pollfd *pfds = spfds;
762 int err;
763 int count;
764 count = snd_mixer_poll_descriptors(mixer, pfds, sizeof(spfds) / sizeof(spfds[0]));
765 if (count < 0)
766 return count;
767 if ((unsigned int) count > sizeof(spfds) / sizeof(spfds[0])) {
768 pfds = malloc(count * sizeof(*pfds));
769 if (!pfds)
770 return -ENOMEM;
771 err = snd_mixer_poll_descriptors(mixer, pfds,
772 (unsigned int) count);
773 assert(err == count);
775 err = poll(pfds, (unsigned int) count, timeout);
776 if (err < 0)
777 return -errno;
778 return 0;
782 * \brief get first element for a mixer
783 * \param mixer Mixer handle
784 * \return pointer to first element
786 snd_mixer_elem_t *snd_mixer_first_elem(snd_mixer_t *mixer)
788 assert(mixer);
789 if (list_empty(&mixer->elems))
790 return NULL;
791 return list_entry(mixer->elems.next, snd_mixer_elem_t, list);
795 * \brief get last element for a mixer
796 * \param mixer Mixer handle
797 * \return pointer to last element
799 snd_mixer_elem_t *snd_mixer_last_elem(snd_mixer_t *mixer)
801 assert(mixer);
802 if (list_empty(&mixer->elems))
803 return NULL;
804 return list_entry(mixer->elems.prev, snd_mixer_elem_t, list);
808 * \brief get next mixer element
809 * \param elem mixer element
810 * \return pointer to next element
812 snd_mixer_elem_t *snd_mixer_elem_next(snd_mixer_elem_t *elem)
814 assert(elem);
815 if (elem->list.next == &elem->class->mixer->elems)
816 return NULL;
817 return list_entry(elem->list.next, snd_mixer_elem_t, list);
821 * \brief get previous mixer element
822 * \param elem mixer element
823 * \return pointer to previous element
825 snd_mixer_elem_t *snd_mixer_elem_prev(snd_mixer_elem_t *elem)
827 assert(elem);
828 if (elem->list.prev == &elem->class->mixer->elems)
829 return NULL;
830 return list_entry(elem->list.prev, snd_mixer_elem_t, list);
834 * \brief Handle pending mixer events invoking callbacks
835 * \param mixer Mixer handle
836 * \return Number of events that occured on success, otherwise a negative error code on failure
838 int snd_mixer_handle_events(snd_mixer_t *mixer)
840 struct list_head *pos;
841 assert(mixer);
842 mixer->events = 0;
843 list_for_each(pos, &mixer->slaves) {
844 int err;
845 snd_mixer_slave_t *s;
846 s = list_entry(pos, snd_mixer_slave_t, list);
847 err = snd_hctl_handle_events(s->hctl);
848 if (err < 0)
849 return err;
851 return mixer->events;
855 * \brief Set callback function for a mixer
856 * \param obj mixer handle
857 * \param val callback function
859 void snd_mixer_set_callback(snd_mixer_t *obj, snd_mixer_callback_t val)
861 assert(obj);
862 obj->callback = val;
866 * \brief Set callback private value for a mixer
867 * \param mixer mixer handle
868 * \param val callback private value
870 void snd_mixer_set_callback_private(snd_mixer_t *mixer, void * val)
872 assert(mixer);
873 mixer->callback_private = val;
877 * \brief Get callback private value for a mixer
878 * \param mixer mixer handle
879 * \return callback private value
881 void * snd_mixer_get_callback_private(const snd_mixer_t *mixer)
883 assert(mixer);
884 return mixer->callback_private;
888 * \brief Get elements count for a mixer
889 * \param mixer mixer handle
890 * \return elements count
892 unsigned int snd_mixer_get_count(const snd_mixer_t *mixer)
894 assert(mixer);
895 return mixer->count;
899 * \brief Set callback function for a mixer element
900 * \param mixer mixer element
901 * \param val callback function
903 void snd_mixer_elem_set_callback(snd_mixer_elem_t *mixer, snd_mixer_elem_callback_t val)
905 assert(mixer);
906 mixer->callback = val;
910 * \brief Set callback private value for a mixer element
911 * \param mixer mixer element
912 * \param val callback private value
914 void snd_mixer_elem_set_callback_private(snd_mixer_elem_t *mixer, void * val)
916 assert(mixer);
917 mixer->callback_private = val;
921 * \brief Get callback private value for a mixer element
922 * \param mixer mixer element
923 * \return callback private value
925 void * snd_mixer_elem_get_callback_private(const snd_mixer_elem_t *mixer)
927 assert(mixer);
928 return mixer->callback_private;
932 * \brief Get type for a mixer element
933 * \param mixer mixer element
934 * \return mixer element type
936 snd_mixer_elem_type_t snd_mixer_elem_get_type(const snd_mixer_elem_t *mixer)
938 assert(mixer);
939 return mixer->type;
944 * \brief get size of #snd_mixer_class_t
945 * \return size in bytes
947 size_t snd_mixer_class_sizeof()
949 return sizeof(snd_mixer_class_t);
953 * \brief allocate an invalid #snd_mixer_class_t using standard malloc
954 * \param ptr returned pointer
955 * \return 0 on success otherwise negative error code
957 int snd_mixer_class_malloc(snd_mixer_class_t **ptr)
959 assert(ptr);
960 *ptr = calloc(1, sizeof(snd_mixer_class_t));
961 if (!*ptr)
962 return -ENOMEM;
963 return 0;
967 * \brief frees a previously allocated #snd_mixer_class_t
968 * \param obj pointer to object to free
970 void snd_mixer_class_free(snd_mixer_class_t *obj)
972 if (obj->private_free)
973 obj->private_free(obj);
974 free(obj);
978 * \brief copy one #snd_mixer_class_t to another
979 * \param dst pointer to destination
980 * \param src pointer to source
982 void snd_mixer_class_copy(snd_mixer_class_t *dst, const snd_mixer_class_t *src)
984 assert(dst && src);
985 *dst = *src;
989 * \brief Get a mixer associated to given mixer class
990 * \param obj Mixer simple class identifier
991 * \return mixer pointer
993 snd_mixer_t *snd_mixer_class_get_mixer(const snd_mixer_class_t *obj)
995 assert(obj);
996 return obj->mixer;
1000 * \brief Get mixer event callback associated to given mixer class
1001 * \param obj Mixer simple class identifier
1002 * \return event callback pointer
1004 snd_mixer_event_t snd_mixer_class_get_event(const snd_mixer_class_t *obj)
1006 assert(obj);
1007 return obj->event;
1011 * \brief Get mixer private data associated to given mixer class
1012 * \param obj Mixer simple class identifier
1013 * \return event callback pointer
1015 void *snd_mixer_class_get_private(const snd_mixer_class_t *obj)
1017 assert(obj);
1018 return obj->private_data;
1023 * \brief Get mixer compare callback associated to given mixer class
1024 * \param obj Mixer simple class identifier
1025 * \return event callback pointer
1027 snd_mixer_compare_t snd_mixer_class_get_compare(const snd_mixer_class_t *obj)
1029 assert(obj);
1030 return obj->compare;
1034 * \brief Set mixer event callback to given mixer class
1035 * \param obj Mixer simple class identifier
1036 * \param event Event callback
1037 * \return zero if success, otherwise a negative error code
1039 int snd_mixer_class_set_event(snd_mixer_class_t *obj, snd_mixer_event_t event)
1041 assert(obj);
1042 obj->event = event;
1043 return 0;
1047 * \brief Set mixer private data to given mixer class
1048 * \param obj Mixer simple class identifier
1049 * \param private_data class private data
1050 * \return zero if success, otherwise a negative error code
1052 int snd_mixer_class_set_private(snd_mixer_class_t *obj, void *private_data)
1054 assert(obj);
1055 obj->private_data = private_data;
1056 return 0;
1060 * \brief Set mixer private data free callback to given mixer class
1061 * \param obj Mixer simple class identifier
1062 * \param private_free Mixer class private data free callback
1063 * \return zero if success, otherwise a negative error code
1065 int snd_mixer_class_set_private_free(snd_mixer_class_t *obj, void (*private_free)(snd_mixer_class_t *class))
1067 assert(obj);
1068 obj->private_free = private_free;
1069 return 0;
1073 * \brief Set mixer compare callback to given mixer class
1074 * \param obj Mixer simple class identifier
1075 * \param compare the compare callback to be used
1076 * \return zero if success, otherwise a negative error code
1078 int snd_mixer_class_set_compare(snd_mixer_class_t *obj, snd_mixer_compare_t compare)
1080 assert(obj);
1081 obj->compare = compare;
1082 return 0;