1 /* mixer.c
2 **
3 ** Copyright 2011, The Android Open Source Project
4 **
5 ** Redistribution and use in source and binary forms, with or without
6 ** modification, are permitted provided that the following conditions are met:
7 ** * Redistributions of source code must retain the above copyright
8 ** notice, this list of conditions and the following disclaimer.
9 ** * Redistributions in binary form must reproduce the above copyright
10 ** notice, this list of conditions and the following disclaimer in the
11 ** documentation and/or other materials provided with the distribution.
12 ** * Neither the name of The Android Open Source Project nor the names of
13 ** its contributors may be used to endorse or promote products derived
14 ** from this software without specific prior written permission.
15 **
16 ** THIS SOFTWARE IS PROVIDED BY The Android Open Source Project ``AS IS'' AND
17 ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 ** ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE
20 ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
26 ** DAMAGE.
27 */
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include <fcntl.h>
34 #include <errno.h>
35 #include <ctype.h>
36
37 #include <linux/ioctl.h>
38 #define __force
39 #define __bitwise
40 #define __user
41 #include <sound/asound.h>
42
43 #include <tinyalsa/asoundlib.h>
44
45 struct mixer_ctl {
46 struct mixer *mixer;
47 struct snd_ctl_elem_info *info;
48 char **ename;
49 };
50
51 struct mixer {
52 int fd;
53 struct snd_ctl_elem_info *info;
54 struct mixer_ctl *ctl;
55 unsigned int count;
56 };
57
mixer_close(struct mixer * mixer)58 void mixer_close(struct mixer *mixer)
59 {
60 unsigned int n,m;
61
62 if (!mixer)
63 return;
64
65 if (mixer->fd >= 0)
66 close(mixer->fd);
67
68 if (mixer->ctl) {
69 for (n = 0; n < mixer->count; n++) {
70 if (mixer->ctl[n].ename) {
71 unsigned int max = mixer->ctl[n].info->value.enumerated.items;
72 for (m = 0; m < max; m++)
73 free(mixer->ctl[n].ename[m]);
74 free(mixer->ctl[n].ename);
75 }
76 }
77 free(mixer->ctl);
78 }
79
80 if (mixer->info)
81 free(mixer->info);
82
83 free(mixer);
84
85 /* TODO: verify frees */
86 }
87
mixer_open(unsigned int card)88 struct mixer *mixer_open(unsigned int card)
89 {
90 struct snd_ctl_elem_list elist;
91 struct snd_ctl_elem_info tmp;
92 struct snd_ctl_elem_id *eid = NULL;
93 struct mixer *mixer = NULL;
94 unsigned int n, m;
95 int fd;
96 char fn[256];
97
98 snprintf(fn, sizeof(fn), "/dev/snd/controlC%u", card);
99 fd = open(fn, O_RDWR);
100 if (fd < 0)
101 return 0;
102
103 memset(&elist, 0, sizeof(elist));
104 if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0)
105 goto fail;
106
107 mixer = calloc(1, sizeof(*mixer));
108 if (!mixer)
109 goto fail;
110
111 mixer->ctl = calloc(elist.count, sizeof(struct mixer_ctl));
112 mixer->info = calloc(elist.count, sizeof(struct snd_ctl_elem_info));
113 if (!mixer->ctl || !mixer->info)
114 goto fail;
115
116 eid = calloc(elist.count, sizeof(struct snd_ctl_elem_id));
117 if (!eid)
118 goto fail;
119
120 mixer->count = elist.count;
121 mixer->fd = fd;
122 elist.space = mixer->count;
123 elist.pids = eid;
124 if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0)
125 goto fail;
126
127 for (n = 0; n < mixer->count; n++) {
128 struct snd_ctl_elem_info *ei = mixer->info + n;
129 ei->id.numid = eid[n].numid;
130 if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, ei) < 0)
131 goto fail;
132 mixer->ctl[n].info = ei;
133 mixer->ctl[n].mixer = mixer;
134 if (ei->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
135 char **enames = calloc(ei->value.enumerated.items, sizeof(char*));
136 if (!enames)
137 goto fail;
138 mixer->ctl[n].ename = enames;
139 for (m = 0; m < ei->value.enumerated.items; m++) {
140 memset(&tmp, 0, sizeof(tmp));
141 tmp.id.numid = ei->id.numid;
142 tmp.value.enumerated.item = m;
143 if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, &tmp) < 0)
144 goto fail;
145 enames[m] = strdup(tmp.value.enumerated.name);
146 if (!enames[m])
147 goto fail;
148 }
149 }
150 }
151
152 free(eid);
153 return mixer;
154
155 fail:
156 /* TODO: verify frees in failure case */
157 if (eid)
158 free(eid);
159 if (mixer)
160 mixer_close(mixer);
161 else if (fd >= 0)
162 close(fd);
163 return 0;
164 }
165
mixer_get_num_ctls(struct mixer * mixer)166 unsigned int mixer_get_num_ctls(struct mixer *mixer)
167 {
168 if (!mixer)
169 return 0;
170
171 return mixer->count;
172 }
173
mixer_get_ctl(struct mixer * mixer,unsigned int id)174 struct mixer_ctl *mixer_get_ctl(struct mixer *mixer, unsigned int id)
175 {
176 if (mixer && (id < mixer->count))
177 return mixer->ctl + id;
178
179 return NULL;
180 }
181
mixer_get_ctl_by_name(struct mixer * mixer,const char * name)182 struct mixer_ctl *mixer_get_ctl_by_name(struct mixer *mixer, const char *name)
183 {
184 unsigned int n;
185
186 if (!mixer)
187 return NULL;
188
189 for (n = 0; n < mixer->count; n++)
190 if (!strcmp(name, (char*) mixer->info[n].id.name))
191 return mixer->ctl + n;
192
193 return NULL;
194 }
195
mixer_ctl_get_name(struct mixer_ctl * ctl,char * name,unsigned int size)196 int mixer_ctl_get_name(struct mixer_ctl *ctl, char *name, unsigned int size)
197 {
198 if (!ctl || !name || (size == 0))
199 return -EINVAL;
200
201 strncpy(name, (char *)ctl->info->id.name, size);
202 return 0;
203 }
204
mixer_ctl_get_type(struct mixer_ctl * ctl)205 enum mixer_ctl_type mixer_ctl_get_type(struct mixer_ctl *ctl)
206 {
207 if (!ctl)
208 return MIXER_CTL_TYPE_UNKNOWN;
209
210 switch (ctl->info->type) {
211 case SNDRV_CTL_ELEM_TYPE_BOOLEAN: return MIXER_CTL_TYPE_BOOL;
212 case SNDRV_CTL_ELEM_TYPE_INTEGER: return MIXER_CTL_TYPE_INT;
213 case SNDRV_CTL_ELEM_TYPE_ENUMERATED: return MIXER_CTL_TYPE_ENUM;
214 case SNDRV_CTL_ELEM_TYPE_BYTES: return MIXER_CTL_TYPE_BYTE;
215 case SNDRV_CTL_ELEM_TYPE_IEC958: return MIXER_CTL_TYPE_IEC958;
216 case SNDRV_CTL_ELEM_TYPE_INTEGER64: return MIXER_CTL_TYPE_INT64;
217 default: return MIXER_CTL_TYPE_UNKNOWN;
218 };
219 }
220
mixer_ctl_get_type_string(struct mixer_ctl * ctl)221 const char *mixer_ctl_get_type_string(struct mixer_ctl *ctl)
222 {
223 if (!ctl)
224 return "";
225
226 switch (ctl->info->type) {
227 case SNDRV_CTL_ELEM_TYPE_BOOLEAN: return "BOOL";
228 case SNDRV_CTL_ELEM_TYPE_INTEGER: return "INT";
229 case SNDRV_CTL_ELEM_TYPE_ENUMERATED: return "ENUM";
230 case SNDRV_CTL_ELEM_TYPE_BYTES: return "BYTE";
231 case SNDRV_CTL_ELEM_TYPE_IEC958: return "IEC958";
232 case SNDRV_CTL_ELEM_TYPE_INTEGER64: return "INT64";
233 default: return "Unknown";
234 };
235 }
236
mixer_ctl_get_num_values(struct mixer_ctl * ctl)237 unsigned int mixer_ctl_get_num_values(struct mixer_ctl *ctl)
238 {
239 if (!ctl)
240 return 0;
241
242 return ctl->info->count;
243 }
244
percent_to_int(struct snd_ctl_elem_info * ei,int percent)245 static int percent_to_int(struct snd_ctl_elem_info *ei, int percent)
246 {
247 int range;
248
249 if (percent > 100)
250 percent = 100;
251 else if (percent < 0)
252 percent = 0;
253
254 range = (ei->value.integer.max - ei->value.integer.min);
255
256 return ei->value.integer.min + (range * percent) / 100;
257 }
258
int_to_percent(struct snd_ctl_elem_info * ei,int value)259 static int int_to_percent(struct snd_ctl_elem_info *ei, int value)
260 {
261 int range = (ei->value.integer.max - ei->value.integer.min);
262
263 if (range == 0)
264 return 0;
265
266 return ((value - ei->value.integer.min) / range) * 100;
267 }
268
mixer_ctl_get_percent(struct mixer_ctl * ctl,unsigned int id)269 int mixer_ctl_get_percent(struct mixer_ctl *ctl, unsigned int id)
270 {
271 if (!ctl || (ctl->info->type != SNDRV_CTL_ELEM_TYPE_INTEGER))
272 return -EINVAL;
273
274 return int_to_percent(ctl->info, mixer_ctl_get_value(ctl, id));
275 }
276
mixer_ctl_set_percent(struct mixer_ctl * ctl,unsigned int id,int percent)277 int mixer_ctl_set_percent(struct mixer_ctl *ctl, unsigned int id, int percent)
278 {
279 if (!ctl || (ctl->info->type != SNDRV_CTL_ELEM_TYPE_INTEGER))
280 return -EINVAL;
281
282 return mixer_ctl_set_value(ctl, id, percent_to_int(ctl->info, percent));
283 }
284
mixer_ctl_get_value(struct mixer_ctl * ctl,unsigned int id)285 int mixer_ctl_get_value(struct mixer_ctl *ctl, unsigned int id)
286 {
287 struct snd_ctl_elem_value ev;
288 int ret;
289
290 if (!ctl || (id >= ctl->info->count))
291 return -EINVAL;
292
293 memset(&ev, 0, sizeof(ev));
294 ev.id.numid = ctl->info->id.numid;
295 ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
296 if (ret < 0)
297 return ret;
298
299 switch (ctl->info->type) {
300 case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
301 return !!ev.value.integer.value[id];
302
303 case SNDRV_CTL_ELEM_TYPE_INTEGER:
304 return ev.value.integer.value[id];
305
306 case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
307 return ev.value.enumerated.item[id];
308
309 default:
310 return -EINVAL;
311 }
312
313 return 0;
314 }
315
mixer_ctl_set_value(struct mixer_ctl * ctl,unsigned int id,int value)316 int mixer_ctl_set_value(struct mixer_ctl *ctl, unsigned int id, int value)
317 {
318 struct snd_ctl_elem_value ev;
319 int ret;
320
321 if (!ctl || (id >= ctl->info->count))
322 return -EINVAL;
323
324 memset(&ev, 0, sizeof(ev));
325 ev.id.numid = ctl->info->id.numid;
326 ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
327 if (ret < 0)
328 return ret;
329
330 switch (ctl->info->type) {
331 case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
332 ev.value.integer.value[id] = !!value;
333 break;
334
335 case SNDRV_CTL_ELEM_TYPE_INTEGER:
336 ev.value.integer.value[id] = value;
337 break;
338
339 case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
340 ev.value.enumerated.item[id] = value;
341 break;
342
343 default:
344 return -EINVAL;
345 }
346
347 return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
348 }
349
mixer_ctl_get_range_min(struct mixer_ctl * ctl)350 int mixer_ctl_get_range_min(struct mixer_ctl *ctl)
351 {
352 struct snd_ctl_elem_value ev;
353 int ret;
354
355 if (!ctl || (ctl->info->type != SNDRV_CTL_ELEM_TYPE_INTEGER))
356 return -EINVAL;
357
358 memset(&ev, 0, sizeof(ev));
359 ev.id.numid = ctl->info->id.numid;
360 ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
361 if (ret < 0)
362 return ret;
363
364 return ctl->info->value.integer.min;
365 }
366
mixer_ctl_get_range_max(struct mixer_ctl * ctl)367 int mixer_ctl_get_range_max(struct mixer_ctl *ctl)
368 {
369 struct snd_ctl_elem_value ev;
370 int ret;
371
372 if (!ctl || (ctl->info->type != SNDRV_CTL_ELEM_TYPE_INTEGER))
373 return -EINVAL;
374
375 memset(&ev, 0, sizeof(ev));
376 ev.id.numid = ctl->info->id.numid;
377 ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
378 if (ret < 0)
379 return ret;
380
381 return ctl->info->value.integer.max;
382 }
383
mixer_ctl_get_num_enums(struct mixer_ctl * ctl)384 unsigned int mixer_ctl_get_num_enums(struct mixer_ctl *ctl)
385 {
386 if (!ctl)
387 return 0;
388
389 return ctl->info->value.enumerated.items;
390 }
391
mixer_ctl_get_enum_string(struct mixer_ctl * ctl,unsigned int enum_id,char * string,unsigned int size)392 int mixer_ctl_get_enum_string(struct mixer_ctl *ctl, unsigned int enum_id,
393 char *string, unsigned int size)
394 {
395 struct snd_ctl_elem_value ev;
396 int ret;
397
398 if (!ctl || (ctl->info->type != SNDRV_CTL_ELEM_TYPE_ENUMERATED) ||
399 (enum_id >= ctl->info->value.enumerated.items))
400 return -EINVAL;
401
402 memset(&ev, 0, sizeof(ev));
403 ev.id.numid = ctl->info->id.numid;
404 ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
405 if (ret < 0)
406 return ret;
407 strncpy(string, (char *)ctl->ename[enum_id], size);
408
409 return 0;
410 }
411
mixer_ctl_set_enum_by_string(struct mixer_ctl * ctl,const char * string)412 int mixer_ctl_set_enum_by_string(struct mixer_ctl *ctl, const char *string)
413 {
414 unsigned int i, num_enums;
415 struct snd_ctl_elem_value ev;
416 int ret;
417
418 if (!ctl || (ctl->info->type != SNDRV_CTL_ELEM_TYPE_ENUMERATED))
419 return -EINVAL;
420
421 num_enums = ctl->info->value.enumerated.items;
422 for (i = 0; i < num_enums; i++) {
423 if (!strcmp(string, ctl->ename[i])) {
424 memset(&ev, 0, sizeof(ev));
425 ev.value.enumerated.item[0] = i;
426 ev.id.numid = ctl->info->id.numid;
427 ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
428 if (ret < 0)
429 return ret;
430 return 0;
431 }
432 }
433
434 return -EINVAL;
435 }
436
437