1 /* $NetBSD: main.c,v 1.7 2024/11/03 10:43:27 rillig Exp $ */ 2 /*- 3 * Copyright (c) 2021 The NetBSD Foundation, Inc. 4 * All rights reserved. 5 * 6 * This code is derived from software contributed to The NetBSD Foundation 7 * by Nia Alarie. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 20 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 22 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 */ 30 #include <sys/audioio.h> 31 #include <sys/ioctl.h> 32 #include <fcntl.h> 33 #include <unistd.h> 34 #include <signal.h> 35 #include <paths.h> 36 #include <curses.h> 37 #include <stdlib.h> 38 #include <err.h> 39 #include "app.h" 40 #include "draw.h" 41 #include "parse.h" 42 43 static void process_device_select(struct aiomixer *, unsigned int); 44 static void open_device(struct aiomixer *, const char *); 45 static void __dead usage(void); 46 static int adjust_level(int, int); 47 static int select_class(struct aiomixer *, unsigned int); 48 static int select_control(struct aiomixer *, unsigned int); 49 static void slide_control(struct aiomixer *, struct aiomixer_control *, bool); 50 static int toggle_set(struct aiomixer *); 51 static void step_up(struct aiomixer *); 52 static void step_down(struct aiomixer *); 53 static int read_key(struct aiomixer *, int); 54 55 static void __dead 56 usage(void) 57 { 58 fputs("aiomixer [-u] [-d device]\n", stderr); 59 exit(1); 60 } 61 62 static int 63 select_class(struct aiomixer *aio, unsigned int n) 64 { 65 struct aiomixer_class *class; 66 unsigned i; 67 68 if (n >= aio->numclasses) 69 return -1; 70 71 class = &aio->classes[n]; 72 aio->widgets_resized = true; 73 aio->class_scroll_y = 0; 74 aio->curcontrol = 0; 75 aio->curclass = n; 76 for (i = 0; i < class->numcontrols; ++i) { 77 class->controls[i].setindex = -1; 78 draw_control(aio, &class->controls[i], false); 79 } 80 draw_classbar(aio); 81 return 0; 82 } 83 84 static int 85 select_control(struct aiomixer *aio, unsigned int n) 86 { 87 struct aiomixer_class *class; 88 struct aiomixer_control *lastcontrol; 89 struct aiomixer_control *control; 90 91 class = &aio->classes[aio->curclass]; 92 93 if (n >= class->numcontrols) 94 return -1; 95 96 lastcontrol = &class->controls[aio->curcontrol]; 97 lastcontrol->setindex = -1; 98 draw_control(aio, lastcontrol, false); 99 100 control = &class->controls[n]; 101 aio->curcontrol = n; 102 control->setindex = 0; 103 draw_control(aio, control, true); 104 105 if (aio->class_scroll_y > control->widget_y) { 106 aio->class_scroll_y = control->widget_y; 107 aio->widgets_resized = true; 108 } 109 110 if ((control->widget_y + control->height) > 111 ((getmaxy(stdscr) - 4) + aio->class_scroll_y)) { 112 aio->class_scroll_y = control->widget_y; 113 aio->widgets_resized = true; 114 } 115 return 0; 116 } 117 118 static int 119 adjust_level(int level, int delta) 120 { 121 if (level > (AUDIO_MAX_GAIN - delta)) 122 return AUDIO_MAX_GAIN; 123 124 if (delta < 0 && level < (AUDIO_MIN_GAIN + (-delta))) 125 return AUDIO_MIN_GAIN; 126 127 return level + delta; 128 } 129 130 static void 131 slide_control(struct aiomixer *aio, 132 struct aiomixer_control *control, bool right) 133 { 134 struct mixer_devinfo *info = &control->info; 135 struct mixer_ctrl value; 136 unsigned char *level; 137 int i, delta; 138 int cur_index = 0; 139 140 if (info->type != AUDIO_MIXER_SET) { 141 value.dev = info->index; 142 value.type = info->type; 143 if (info->type == AUDIO_MIXER_VALUE) 144 value.un.value.num_channels = info->un.v.num_channels; 145 146 if (ioctl(aio->fd, AUDIO_MIXER_READ, &value) < 0) 147 err(EXIT_FAILURE, "failed to read mixer control"); 148 } 149 150 switch (info->type) { 151 case AUDIO_MIXER_VALUE: 152 if (info->un.v.delta != 0) { 153 delta = right ? info->un.v.delta : -info->un.v.delta; 154 } else { 155 /* delta is 0 in qemu with sb(4) */ 156 delta = right ? 16 : -16; 157 } 158 /* 159 * work around strange problem where the level can be 160 * increased but not decreased, seen with uaudio(4) 161 */ 162 if (delta < 16) 163 delta *= 2; 164 if (aio->channels_unlocked) { 165 level = &value.un.value.level[control->setindex]; 166 *level = (unsigned char)adjust_level(*level, delta); 167 } else { 168 for (i = 0; i < value.un.value.num_channels; ++i) { 169 level = &value.un.value.level[i]; 170 *level = (unsigned char)adjust_level(*level, delta); 171 } 172 } 173 break; 174 case AUDIO_MIXER_ENUM: 175 for (i = 0; i < info->un.e.num_mem; ++i) { 176 if (info->un.e.member[i].ord == value.un.ord) { 177 cur_index = i; 178 break; 179 } 180 } 181 if (right) { 182 value.un.ord = cur_index < (info->un.e.num_mem - 1) ? 183 info->un.e.member[cur_index + 1].ord : 184 info->un.e.member[0].ord; 185 } else { 186 value.un.ord = cur_index > 0 ? 187 info->un.e.member[cur_index - 1].ord : 188 info->un.e.member[control->info.un.e.num_mem - 1].ord; 189 } 190 break; 191 case AUDIO_MIXER_SET: 192 if (right) { 193 control->setindex = 194 control->setindex < (info->un.s.num_mem - 1) ? 195 control->setindex + 1 : 0; 196 } else { 197 control->setindex = control->setindex > 0 ? 198 control->setindex - 1 : 199 control->info.un.s.num_mem - 1; 200 } 201 break; 202 } 203 204 if (info->type != AUDIO_MIXER_SET) { 205 if (ioctl(aio->fd, AUDIO_MIXER_WRITE, &value) < 0) 206 err(EXIT_FAILURE, "failed to adjust mixer control"); 207 } 208 209 draw_control(aio, control, true); 210 } 211 212 static int 213 toggle_set(struct aiomixer *aio) 214 { 215 struct mixer_ctrl ctrl; 216 struct aiomixer_class *class = &aio->classes[aio->curclass]; 217 struct aiomixer_control *control = &class->controls[aio->curcontrol]; 218 219 ctrl.dev = control->info.index; 220 ctrl.type = control->info.type; 221 222 if (control->info.type != AUDIO_MIXER_SET) 223 return -1; 224 225 if (ioctl(aio->fd, AUDIO_MIXER_READ, &ctrl) < 0) 226 err(EXIT_FAILURE, "failed to read mixer control"); 227 228 ctrl.un.mask ^= control->info.un.s.member[control->setindex].mask; 229 230 if (ioctl(aio->fd, AUDIO_MIXER_WRITE, &ctrl) < 0) 231 err(EXIT_FAILURE, "failed to read mixer control"); 232 233 draw_control(aio, control, true); 234 return 0; 235 } 236 237 static void 238 step_up(struct aiomixer *aio) 239 { 240 struct aiomixer_class *class; 241 struct aiomixer_control *control; 242 243 class = &aio->classes[aio->curclass]; 244 control = &class->controls[aio->curcontrol]; 245 246 if (aio->channels_unlocked && 247 control->info.type == AUDIO_MIXER_VALUE && 248 control->setindex > 0) { 249 control->setindex--; 250 draw_control(aio, control, true); 251 return; 252 } 253 select_control(aio, aio->curcontrol - 1); 254 } 255 256 static void 257 step_down(struct aiomixer *aio) 258 { 259 struct aiomixer_class *class; 260 struct aiomixer_control *control; 261 262 class = &aio->classes[aio->curclass]; 263 control = &class->controls[aio->curcontrol]; 264 265 if (aio->channels_unlocked && 266 control->info.type == AUDIO_MIXER_VALUE && 267 control->setindex < (control->info.un.v.num_channels - 1)) { 268 control->setindex++; 269 draw_control(aio, control, true); 270 return; 271 } 272 273 select_control(aio, (aio->curcontrol + 1) % class->numcontrols); 274 } 275 276 static int 277 read_key(struct aiomixer *aio, int ch) 278 { 279 struct aiomixer_class *class; 280 struct aiomixer_control *control; 281 size_t i; 282 283 switch (ch) { 284 case KEY_RESIZE: 285 class = &aio->classes[aio->curclass]; 286 resize_widgets(aio); 287 draw_header(aio); 288 draw_classbar(aio); 289 for (i = 0; i < class->numcontrols; ++i) { 290 draw_control(aio, 291 &class->controls[i], 292 aio->state == STATE_CONTROL_SELECT ? 293 (aio->curcontrol == i) : false); 294 } 295 break; 296 case KEY_LEFT: 297 case 'h': 298 if (aio->state == STATE_CLASS_SELECT) { 299 select_class(aio, aio->curclass > 0 ? 300 aio->curclass - 1 : aio->numclasses - 1); 301 } else if (aio->state == STATE_CONTROL_SELECT) { 302 class = &aio->classes[aio->curclass]; 303 slide_control(aio, 304 &class->controls[aio->curcontrol], false); 305 } 306 break; 307 case KEY_RIGHT: 308 case 'l': 309 if (aio->state == STATE_CLASS_SELECT) { 310 select_class(aio, 311 (aio->curclass + 1) % aio->numclasses); 312 } else if (aio->state == STATE_CONTROL_SELECT) { 313 class = &aio->classes[aio->curclass]; 314 slide_control(aio, 315 &class->controls[aio->curcontrol], true); 316 } 317 break; 318 case KEY_UP: 319 case 'k': 320 if (aio->state == STATE_CONTROL_SELECT) { 321 if (aio->curcontrol == 0) { 322 class = &aio->classes[aio->curclass]; 323 control = &class->controls[aio->curcontrol]; 324 control->setindex = -1; 325 aio->state = STATE_CLASS_SELECT; 326 draw_control(aio, control, false); 327 } else { 328 step_up(aio); 329 } 330 } 331 break; 332 case KEY_DOWN: 333 case 'j': 334 if (aio->state == STATE_CLASS_SELECT) { 335 class = &aio->classes[aio->curclass]; 336 if (class->numcontrols > 0) { 337 aio->state = STATE_CONTROL_SELECT; 338 select_control(aio, 0); 339 } 340 } else if (aio->state == STATE_CONTROL_SELECT) { 341 step_down(aio); 342 } 343 break; 344 case '\n': 345 case ' ': 346 if (aio->state == STATE_CONTROL_SELECT) 347 toggle_set(aio); 348 break; 349 case '1': 350 select_class(aio, 0); 351 break; 352 case '2': 353 select_class(aio, 1); 354 break; 355 case '3': 356 select_class(aio, 2); 357 break; 358 case '4': 359 select_class(aio, 3); 360 break; 361 case '5': 362 select_class(aio, 4); 363 break; 364 case '6': 365 select_class(aio, 5); 366 break; 367 case '7': 368 select_class(aio, 6); 369 break; 370 case '8': 371 select_class(aio, 7); 372 break; 373 case '9': 374 select_class(aio, 8); 375 break; 376 case 'q': 377 case '\e': 378 if (aio->state == STATE_CONTROL_SELECT) { 379 class = &aio->classes[aio->curclass]; 380 control = &class->controls[aio->curcontrol]; 381 aio->state = STATE_CLASS_SELECT; 382 draw_control(aio, control, false); 383 break; 384 } 385 return 1; 386 case 'u': 387 aio->channels_unlocked = !aio->channels_unlocked; 388 if (aio->state == STATE_CONTROL_SELECT) { 389 class = &aio->classes[aio->curclass]; 390 control = &class->controls[aio->curcontrol]; 391 if (control->info.type == AUDIO_MIXER_VALUE) 392 draw_control(aio, control, true); 393 } 394 break; 395 } 396 397 draw_screen(aio); 398 return 0; 399 } 400 401 static void 402 process_device_select(struct aiomixer *aio, unsigned int num_devices) 403 { 404 unsigned int selected_device = 0; 405 char device_path[16]; 406 int ch; 407 408 draw_mixer_select(num_devices, selected_device); 409 410 while ((ch = getch()) != ERR) { 411 switch (ch) { 412 case '\n': 413 clear(); 414 (void)snprintf(device_path, sizeof(device_path), 415 "/dev/mixer%d", selected_device); 416 open_device(aio, device_path); 417 return; 418 case KEY_UP: 419 case 'k': 420 if (selected_device > 0) 421 selected_device--; 422 else 423 selected_device = (num_devices - 1); 424 break; 425 case KEY_DOWN: 426 case 'j': 427 if (selected_device < (num_devices - 1)) 428 selected_device++; 429 else 430 selected_device = 0; 431 break; 432 case '1': 433 selected_device = 0; 434 break; 435 case '2': 436 selected_device = 1; 437 break; 438 case '3': 439 selected_device = 2; 440 break; 441 case '4': 442 selected_device = 3; 443 break; 444 case '5': 445 selected_device = 4; 446 break; 447 case '6': 448 selected_device = 5; 449 break; 450 case '7': 451 selected_device = 6; 452 break; 453 case '8': 454 selected_device = 7; 455 break; 456 case '9': 457 selected_device = 8; 458 break; 459 } 460 draw_mixer_select(num_devices, selected_device); 461 } 462 } 463 464 static void 465 open_device(struct aiomixer *aio, const char *device) 466 { 467 int ch; 468 469 if ((aio->fd = open(device, O_RDWR)) < 0) 470 err(EXIT_FAILURE, "couldn't open mixer device"); 471 472 if (ioctl(aio->fd, AUDIO_GETDEV, &aio->mixerdev) < 0) 473 err(EXIT_FAILURE, "AUDIO_GETDEV failed"); 474 475 aio->state = STATE_CLASS_SELECT; 476 477 aiomixer_parse(aio); 478 479 create_widgets(aio); 480 481 draw_header(aio); 482 select_class(aio, 0); 483 draw_screen(aio); 484 485 while ((ch = getch()) != ERR) { 486 if (read_key(aio, ch) != 0) 487 break; 488 } 489 } 490 491 static __dead void 492 on_signal(int dummy) 493 { 494 endwin(); 495 exit(0); 496 } 497 498 int 499 main(int argc, char **argv) 500 { 501 const char *mixer_device = NULL; 502 struct aiomixer *aio; 503 char mixer_path[32]; 504 unsigned int mixer_count = 0; 505 int i, fd; 506 int ch; 507 char *no_color = getenv("NO_COLOR"); 508 509 if ((aio = malloc(sizeof(struct aiomixer))) == NULL) { 510 err(EXIT_FAILURE, "malloc failed"); 511 } 512 513 while ((ch = getopt(argc, argv, "d:u")) != -1) { 514 switch (ch) { 515 case 'd': 516 mixer_device = optarg; 517 break; 518 case 'u': 519 aio->channels_unlocked = true; 520 break; 521 default: 522 usage(); 523 break; 524 } 525 } 526 527 argc -= optind; 528 argv += optind; 529 530 if (initscr() == NULL) 531 err(EXIT_FAILURE, "can't initialize curses"); 532 533 (void)signal(SIGHUP, on_signal); 534 (void)signal(SIGINT, on_signal); 535 (void)signal(SIGTERM, on_signal); 536 537 curs_set(0); 538 keypad(stdscr, TRUE); 539 cbreak(); 540 noecho(); 541 542 aio->use_colour = true; 543 544 if (!has_colors()) 545 aio->use_colour = false; 546 547 if (no_color != NULL && no_color[0] != '\0') 548 aio->use_colour = false; 549 550 if (aio->use_colour) { 551 start_color(); 552 use_default_colors(); 553 init_pair(COLOR_CONTROL_SELECTED, COLOR_BLUE, COLOR_BLACK); 554 init_pair(COLOR_LEVELS, COLOR_GREEN, COLOR_BLACK); 555 init_pair(COLOR_SET_SELECTED, COLOR_BLACK, COLOR_GREEN); 556 init_pair(COLOR_ENUM_ON, COLOR_WHITE, COLOR_RED); 557 init_pair(COLOR_ENUM_OFF, COLOR_WHITE, COLOR_BLUE); 558 init_pair(COLOR_ENUM_MISC, COLOR_BLACK, COLOR_YELLOW); 559 } 560 561 if (mixer_device != NULL) { 562 open_device(aio, mixer_device); 563 } else { 564 for (i = 0; i < 16; ++i) { 565 (void)snprintf(mixer_path, sizeof(mixer_path), 566 "/dev/mixer%d", i); 567 fd = open(mixer_path, O_RDWR); 568 if (fd == -1) 569 break; 570 close(fd); 571 mixer_count++; 572 } 573 574 if (mixer_count > 1) { 575 process_device_select(aio, mixer_count); 576 } else { 577 open_device(aio, _PATH_MIXER); 578 } 579 } 580 581 endwin(); 582 close(aio->fd); 583 free(aio); 584 585 return 0; 586 } 587
Indexes created Sat Sep 20 22:09:52 GMT 2025