The opus audio format handler.
[paraslash.git] / alsa_mix.c
1 /*
2 * Copyright (C) 2012-2013 Andre Noll <maan@systemlinux.org>
3 *
4 * Licensed under the GPL v2. For licencing details see COPYING.
5 */
6
7 /** \file alsa_mix.c The ALSA mixer plugin. */
8
9 #include <regex.h>
10 #include <alsa/asoundlib.h>
11
12 #include "para.h"
13 #include "error.h"
14 #include "mix.h"
15 #include "string.h"
16
17 struct mixer_handle {
18 /* The ALSA mixer handle */
19 snd_mixer_t *mixer;
20 /* Copy of the alsa device name, e.g. "hw:0". */
21 char *card;
22 /* ALSA's representation of the given mixer channel. */
23 snd_mixer_elem_t *elem;
24 /* Set in ->set_channel(), used for ->get() and ->set(). */
25 long pmin, pmax;
26 };
27
28 static void alsa_mix_close(struct mixer_handle **handle)
29 {
30 struct mixer_handle *h;
31
32 if (!handle)
33 return;
34 h = *handle;
35 if (h) {
36 PARA_INFO_LOG("closing mixer handle\n");
37 if (h->mixer) /* nec. */
38 snd_mixer_close(h->mixer);
39 free(h->card);
40 free(h);
41 /*
42 * The global ALSA configuration is cached for next usage,
43 * which causes valgrind to report many memory leaks. Calling
44 * snd_config_update_free_global() frees the cache.
45 */
46 snd_config_update_free_global();
47 }
48 *handle = NULL;
49 }
50
51 static int alsa_mix_open(const char *dev, struct mixer_handle **handle)
52 {
53 int ret;
54 char *msg;
55 struct mixer_handle *h;
56
57 PARA_INFO_LOG("snd_mixer_{open,attach,register,load}\n");
58 *handle = NULL;
59 h = para_calloc(sizeof(*h));
60 h->card = para_strdup(dev? dev : "hw:0");
61 ret = snd_mixer_open(&h->mixer, 0);
62 if (ret < 0) {
63 msg = make_message("snd_mixer_open() failed: %s",
64 snd_strerror(ret));
65 goto fail;
66 }
67 ret = snd_mixer_attach(h->mixer, h->card);
68 if (ret < 0) {
69 msg = make_message("mixer attach error (%s): %s", h->card,
70 snd_strerror(ret));
71 goto fail;
72 }
73 ret = snd_mixer_selem_register(h->mixer, NULL, NULL);
74 if (ret < 0) {
75 msg = make_message("mixer register error (%s): %s", h->card,
76 snd_strerror(ret));
77 goto fail;
78 }
79 ret = snd_mixer_load(h->mixer);
80 if (ret < 0) {
81 msg = make_message("mixer load error (%s): %s", h->card,
82 snd_strerror(ret));
83 goto fail;
84 }
85 /* success */
86 *handle = h;
87 return 1;
88 fail:
89 PARA_NOTICE_LOG("%s\n", msg);
90 free(msg);
91 alsa_mix_close(&h);
92 return -E_ALSA_MIX_OPEN;
93 }
94
95 static bool channel_has_playback(snd_mixer_selem_channel_id_t chn,
96 snd_mixer_elem_t *elem)
97 {
98 return snd_mixer_selem_has_playback_channel(elem, chn);
99 }
100
101 static char *alsa_mix_get_channels(struct mixer_handle *handle)
102 {
103 char *list = NULL;
104 snd_mixer_selem_id_t *sid;
105 snd_mixer_elem_t *elem;
106
107 snd_mixer_selem_id_alloca(&sid);
108 elem = snd_mixer_first_elem(handle->mixer);
109 for (; elem; elem = snd_mixer_elem_next(elem)) {
110 char *tmp = list;
111 const char *name;
112
113 if (!channel_has_playback(0, elem))
114 continue;
115 if (!snd_mixer_selem_has_playback_volume(elem))
116 continue;
117 snd_mixer_selem_get_id(elem, sid);
118 name = snd_mixer_selem_id_get_name(sid);
119 list = make_message("%s%s%s",
120 list? list : "",
121 list? ", " : "",
122 name);
123 free(tmp);
124 }
125 return list;
126 }
127
128 static int alsa_mix_set_channel(struct mixer_handle *h,
129 const char *mixer_channel)
130 {
131 int ret, selem_id = 0;
132 snd_mixer_selem_id_t *sid;
133
134 if (!mixer_channel)
135 mixer_channel = "Master";
136 snd_mixer_selem_id_alloca(&sid);
137 snd_mixer_selem_id_set_index(sid, selem_id);
138 snd_mixer_selem_id_set_name(sid, mixer_channel);
139 h->elem = snd_mixer_find_selem(h->mixer, sid);
140 if (!h->elem) {
141 PARA_NOTICE_LOG("unable to find simple control '%s',%i\n",
142 snd_mixer_selem_id_get_name(sid),
143 snd_mixer_selem_id_get_index(sid));
144 return -E_ALSA_MIX_BAD_ELEM;
145 }
146 ret = snd_mixer_selem_get_playback_volume_range(h->elem,
147 &h->pmin, &h->pmax);
148 if (ret < 0) {
149 PARA_NOTICE_LOG("unable to get %s range (%s): %s\n",
150 mixer_channel, h->card, snd_strerror(ret));
151 return -E_ALSA_MIX_BAD_ELEM;
152 }
153 if (h->pmin < 0 || h->pmax < 0 || h->pmin >= h->pmax) {
154 PARA_NOTICE_LOG("alsa reported %s range %ld-%ld (%s)\n",
155 mixer_channel, h->pmin, h->pmax, h->card);
156 return -E_ALSA_MIX_BAD_ELEM;
157 }
158 return 1;
159 }
160
161 static int alsa_mix_get(struct mixer_handle *h)
162 {
163 snd_mixer_selem_channel_id_t chn;
164 int n = 0;
165 float avg = 0;
166
167 /* compute average over all channels */
168 for (chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++) {
169 long val;
170 int ret;
171
172 if (!channel_has_playback(chn, h->elem))
173 continue;
174 ret = snd_mixer_selem_get_playback_volume(h->elem, chn, &val);
175 if (ret < 0) {
176 PARA_NOTICE_LOG("unable to get value for channel %d (%s): %s\n",
177 (int)chn, h->card, snd_strerror(ret));
178 return -E_ALSA_MIX_GET_VAL;
179 }
180 /* update the rolling average */
181 avg = (val + n * avg) / (n + 1);
182 n++;
183 }
184 /* scale to 0..100 */
185 avg = 100 * (avg - h->pmin) / (h->pmax - h->pmin);
186 return avg;
187 }
188
189 static int alsa_mix_set(struct mixer_handle *h, int val)
190 {
191 int ret;
192 snd_mixer_selem_channel_id_t chn;
193 long scaled = val / 100.0 * (h->pmax - h->pmin) + h->pmin;
194
195 PARA_INFO_LOG("new value: %d\n", val);
196 for (chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++) {
197 if (!channel_has_playback(chn, h->elem))
198 continue;
199 ret = snd_mixer_selem_set_playback_volume(h->elem, chn, scaled);
200 if (ret < 0) {
201 PARA_NOTICE_LOG("unable to set value for channel %d (%s): %s\n",
202 (int)chn, h->card, snd_strerror(ret));
203 return -E_ALSA_MIX_SET_VAL;
204 }
205 }
206 return 1;
207 }
208
209 /**
210 * The init function of the ALSA mixer.
211 *
212 * \param self The structure to initialize.
213 *
214 * \sa struct \ref mixer, \ref oss_mix_init().
215 */
216 void alsa_mix_init(struct mixer *self)
217 {
218 self->open = alsa_mix_open;
219 self->get_channels = alsa_mix_get_channels;
220 self->set_channel = alsa_mix_set_channel;
221 self->close = alsa_mix_close;
222 self->get = alsa_mix_get;
223 self->set = alsa_mix_set;
224 }