1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * Inspired by TinyHW, written by Mark Brown at Wolfson Micro 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 #define LOG_TAG "audio_route" 19 /*#define LOG_NDEBUG 0*/ 20 21 #include <errno.h> 22 #include <expat.h> 23 #include <stdbool.h> 24 #include <stdio.h> 25 #include <string.h> 26 27 #include <log/log.h> 28 29 #include <tinyalsa/asoundlib.h> 30 31 #define BUF_SIZE 1024 32 #define MIXER_XML_PATH "/system/etc/mixer_paths.xml" 33 #define INITIAL_MIXER_PATH_SIZE 8 34 35 union ctl_values { 36 int *enumerated; 37 long *integer; 38 void *ptr; 39 unsigned char *bytes; 40 }; 41 42 struct mixer_state { 43 struct mixer_ctl *ctl; 44 unsigned int num_values; 45 union ctl_values old_value; 46 union ctl_values new_value; 47 union ctl_values reset_value; 48 }; 49 50 struct mixer_setting { 51 unsigned int ctl_index; 52 unsigned int num_values; 53 unsigned int type; 54 union ctl_values value; 55 }; 56 57 struct mixer_value { 58 unsigned int ctl_index; 59 int index; 60 long value; 61 }; 62 63 struct mixer_path { 64 char *name; 65 unsigned int size; 66 unsigned int length; 67 struct mixer_setting *setting; 68 }; 69 70 struct audio_route { 71 struct mixer *mixer; 72 unsigned int num_mixer_ctls; 73 struct mixer_state *mixer_state; 74 75 unsigned int mixer_path_size; 76 unsigned int num_mixer_paths; 77 struct mixer_path *mixer_path; 78 }; 79 80 struct config_parse_state { 81 struct audio_route *ar; 82 struct mixer_path *path; 83 int level; 84 }; 85 86 /* path functions */ 87 88 static bool is_supported_ctl_type(enum mixer_ctl_type type) 89 { 90 switch (type) { 91 case MIXER_CTL_TYPE_BOOL: 92 case MIXER_CTL_TYPE_INT: 93 case MIXER_CTL_TYPE_ENUM: 94 case MIXER_CTL_TYPE_BYTE: 95 return true; 96 default: 97 return false; 98 } 99 } 100 101 /* as they match in alsa */ 102 static size_t sizeof_ctl_type(enum mixer_ctl_type type) { 103 switch (type) { 104 case MIXER_CTL_TYPE_BOOL: 105 case MIXER_CTL_TYPE_INT: 106 return sizeof(long); 107 case MIXER_CTL_TYPE_ENUM: 108 return sizeof(int); 109 case MIXER_CTL_TYPE_BYTE: 110 return sizeof(unsigned char); 111 case MIXER_CTL_TYPE_INT64: 112 case MIXER_CTL_TYPE_IEC958: 113 case MIXER_CTL_TYPE_UNKNOWN: 114 default: 115 LOG_ALWAYS_FATAL("Unsupported mixer ctl type: %d, check type before calling", (int)type); 116 return 0; 117 } 118 } 119 120 static inline struct mixer_ctl *index_to_ctl(struct audio_route *ar, 121 unsigned int ctl_index) 122 { 123 return ar->mixer_state[ctl_index].ctl; 124 } 125 126 #if 0 127 static void path_print(struct audio_route *ar, struct mixer_path *path) 128 { 129 unsigned int i; 130 unsigned int j; 131 132 ALOGE("Path: %s, length: %d", path->name, path->length); 133 for (i = 0; i < path->length; i++) { 134 struct mixer_ctl *ctl = index_to_ctl(ar, path->setting[i].ctl_index); 135 136 ALOGE(" id=%d: ctl=%s", i, mixer_ctl_get_name(ctl)); 137 if (mixer_ctl_get_type(ctl) == MIXER_CTL_TYPE_BYTE) { 138 for (j = 0; j < path->setting[i].num_values; j++) 139 ALOGE(" id=%d value=0x%02x", j, path->setting[i].value.bytes[j]); 140 } else if (mixer_ctl_get_type(ctl) == MIXER_CTL_TYPE_ENUM) { 141 for (j = 0; j < path->setting[i].num_values; j++) 142 ALOGE(" id=%d value=%d", j, path->setting[i].value.enumerated[j]); 143 } else { 144 for (j = 0; j < path->setting[i].num_values; j++) 145 ALOGE(" id=%d value=%ld", j, path->setting[i].value.integer[j]); 146 } 147 } 148 } 149 #endif 150 151 static void path_free(struct audio_route *ar) 152 { 153 unsigned int i; 154 155 for (i = 0; i < ar->num_mixer_paths; i++) { 156 free(ar->mixer_path[i].name); 157 if (ar->mixer_path[i].setting) { 158 free(ar->mixer_path[i].setting->value.ptr); 159 free(ar->mixer_path[i].setting); 160 } 161 } 162 free(ar->mixer_path); 163 ar->mixer_path = NULL; 164 ar->mixer_path_size = 0; 165 ar->num_mixer_paths = 0; 166 } 167 168 static struct mixer_path *path_get_by_name(struct audio_route *ar, 169 const char *name) 170 { 171 unsigned int i; 172 173 for (i = 0; i < ar->num_mixer_paths; i++) 174 if (strcmp(ar->mixer_path[i].name, name) == 0) 175 return &ar->mixer_path[i]; 176 177 return NULL; 178 } 179 180 static struct mixer_path *path_create(struct audio_route *ar, const char *name) 181 { 182 struct mixer_path *new_mixer_path = NULL; 183 184 if (path_get_by_name(ar, name)) { 185 ALOGE("Path name '%s' already exists", name); 186 return NULL; 187 } 188 189 /* check if we need to allocate more space for mixer paths */ 190 if (ar->mixer_path_size <= ar->num_mixer_paths) { 191 if (ar->mixer_path_size == 0) 192 ar->mixer_path_size = INITIAL_MIXER_PATH_SIZE; 193 else 194 ar->mixer_path_size *= 2; 195 196 new_mixer_path = realloc(ar->mixer_path, ar->mixer_path_size * 197 sizeof(struct mixer_path)); 198 if (new_mixer_path == NULL) { 199 ALOGE("Unable to allocate more paths"); 200 return NULL; 201 } else { 202 ar->mixer_path = new_mixer_path; 203 } 204 } 205 206 /* initialise the new mixer path */ 207 ar->mixer_path[ar->num_mixer_paths].name = strdup(name); 208 ar->mixer_path[ar->num_mixer_paths].size = 0; 209 ar->mixer_path[ar->num_mixer_paths].length = 0; 210 ar->mixer_path[ar->num_mixer_paths].setting = NULL; 211 212 /* return the mixer path just added, then increment number of them */ 213 return &ar->mixer_path[ar->num_mixer_paths++]; 214 } 215 216 static int find_ctl_index_in_path(struct mixer_path *path, 217 unsigned int ctl_index) 218 { 219 unsigned int i; 220 221 for (i = 0; i < path->length; i++) 222 if (path->setting[i].ctl_index == ctl_index) 223 return i; 224 225 return -1; 226 } 227 228 static int alloc_path_setting(struct mixer_path *path) 229 { 230 struct mixer_setting *new_path_setting; 231 int path_index; 232 233 /* check if we need to allocate more space for path settings */ 234 if (path->size <= path->length) { 235 if (path->size == 0) 236 path->size = INITIAL_MIXER_PATH_SIZE; 237 else 238 path->size *= 2; 239 240 new_path_setting = realloc(path->setting, 241 path->size * sizeof(struct mixer_setting)); 242 if (new_path_setting == NULL) { 243 ALOGE("Unable to allocate more path settings"); 244 return -1; 245 } else { 246 path->setting = new_path_setting; 247 } 248 } 249 250 path_index = path->length; 251 path->length++; 252 253 return path_index; 254 } 255 256 static int path_add_setting(struct audio_route *ar, struct mixer_path *path, 257 struct mixer_setting *setting) 258 { 259 int path_index; 260 261 if (find_ctl_index_in_path(path, setting->ctl_index) != -1) { 262 struct mixer_ctl *ctl = index_to_ctl(ar, setting->ctl_index); 263 264 ALOGE("Control '%s' already exists in path '%s'", 265 mixer_ctl_get_name(ctl), path->name); 266 return -1; 267 } 268 269 if (!is_supported_ctl_type(setting->type)) { 270 ALOGE("unsupported type %d", (int)setting->type); 271 return -1; 272 } 273 274 path_index = alloc_path_setting(path); 275 if (path_index < 0) 276 return -1; 277 278 path->setting[path_index].ctl_index = setting->ctl_index; 279 path->setting[path_index].type = setting->type; 280 path->setting[path_index].num_values = setting->num_values; 281 282 size_t value_sz = sizeof_ctl_type(setting->type); 283 284 path->setting[path_index].value.ptr = calloc(setting->num_values, value_sz); 285 /* copy all values */ 286 memcpy(path->setting[path_index].value.ptr, setting->value.ptr, 287 setting->num_values * value_sz); 288 289 return 0; 290 } 291 292 static int path_add_value(struct audio_route *ar, struct mixer_path *path, 293 struct mixer_value *mixer_value) 294 { 295 unsigned int i; 296 int path_index; 297 unsigned int num_values; 298 struct mixer_ctl *ctl; 299 300 /* Check that mixer value index is within range */ 301 ctl = index_to_ctl(ar, mixer_value->ctl_index); 302 num_values = mixer_ctl_get_num_values(ctl); 303 if (mixer_value->index >= (int)num_values) { 304 ALOGE("mixer index %d is out of range for '%s'", mixer_value->index, 305 mixer_ctl_get_name(ctl)); 306 return -1; 307 } 308 309 path_index = find_ctl_index_in_path(path, mixer_value->ctl_index); 310 if (path_index < 0) { 311 /* New path */ 312 313 enum mixer_ctl_type type = mixer_ctl_get_type(ctl); 314 if (!is_supported_ctl_type(type)) { 315 ALOGE("unsupported type %d", (int)type); 316 return -1; 317 } 318 path_index = alloc_path_setting(path); 319 if (path_index < 0) 320 return -1; 321 322 /* initialise the new path setting */ 323 path->setting[path_index].ctl_index = mixer_value->ctl_index; 324 path->setting[path_index].num_values = num_values; 325 path->setting[path_index].type = type; 326 327 size_t value_sz = sizeof_ctl_type(type); 328 path->setting[path_index].value.ptr = calloc(num_values, value_sz); 329 if (path->setting[path_index].type == MIXER_CTL_TYPE_BYTE) 330 path->setting[path_index].value.bytes[0] = mixer_value->value; 331 else if (path->setting[path_index].type == MIXER_CTL_TYPE_ENUM) 332 path->setting[path_index].value.enumerated[0] = mixer_value->value; 333 else 334 path->setting[path_index].value.integer[0] = mixer_value->value; 335 } 336 337 if (mixer_value->index == -1) { 338 /* set all values the same */ 339 if (path->setting[path_index].type == MIXER_CTL_TYPE_BYTE) { 340 for (i = 0; i < num_values; i++) 341 path->setting[path_index].value.bytes[i] = mixer_value->value; 342 } else if (path->setting[path_index].type == MIXER_CTL_TYPE_ENUM) { 343 for (i = 0; i < num_values; i++) 344 path->setting[path_index].value.enumerated[i] = mixer_value->value; 345 } else { 346 for (i = 0; i < num_values; i++) 347 path->setting[path_index].value.integer[i] = mixer_value->value; 348 } 349 } else { 350 /* set only one value */ 351 if (path->setting[path_index].type == MIXER_CTL_TYPE_BYTE) 352 path->setting[path_index].value.bytes[mixer_value->index] = mixer_value->value; 353 else if (path->setting[path_index].type == MIXER_CTL_TYPE_ENUM) 354 path->setting[path_index].value.enumerated[mixer_value->index] = mixer_value->value; 355 else 356 path->setting[path_index].value.integer[mixer_value->index] = mixer_value->value; 357 } 358 359 return 0; 360 } 361 362 static int path_add_path(struct audio_route *ar, struct mixer_path *path, 363 struct mixer_path *sub_path) 364 { 365 unsigned int i; 366 367 for (i = 0; i < sub_path->length; i++) 368 if (path_add_setting(ar, path, &sub_path->setting[i]) < 0) 369 return -1; 370 371 return 0; 372 } 373 374 static int path_apply(struct audio_route *ar, struct mixer_path *path) 375 { 376 unsigned int i; 377 unsigned int ctl_index; 378 struct mixer_ctl *ctl; 379 enum mixer_ctl_type type; 380 381 ALOGD("Apply path: %s", path->name != NULL ? path->name : "none"); 382 for (i = 0; i < path->length; i++) { 383 ctl_index = path->setting[i].ctl_index; 384 ctl = index_to_ctl(ar, ctl_index); 385 type = mixer_ctl_get_type(ctl); 386 if (!is_supported_ctl_type(type)) 387 continue; 388 size_t value_sz = sizeof_ctl_type(type); 389 memcpy(ar->mixer_state[ctl_index].new_value.ptr, path->setting[i].value.ptr, 390 path->setting[i].num_values * value_sz); 391 } 392 393 return 0; 394 } 395 396 static int path_reset(struct audio_route *ar, struct mixer_path *path) 397 { 398 unsigned int i; 399 unsigned int ctl_index; 400 struct mixer_ctl *ctl; 401 enum mixer_ctl_type type; 402 403 ALOGV("Reset path: %s", path->name != NULL ? path->name : "none"); 404 for (i = 0; i < path->length; i++) { 405 ctl_index = path->setting[i].ctl_index; 406 ctl = index_to_ctl(ar, ctl_index); 407 type = mixer_ctl_get_type(ctl); 408 if (!is_supported_ctl_type(type)) 409 continue; 410 size_t value_sz = sizeof_ctl_type(type); 411 /* reset the value(s) */ 412 memcpy(ar->mixer_state[ctl_index].new_value.ptr, 413 ar->mixer_state[ctl_index].reset_value.ptr, 414 ar->mixer_state[ctl_index].num_values * value_sz); 415 } 416 417 return 0; 418 } 419 420 /* mixer helper function */ 421 static int mixer_enum_string_to_value(struct mixer_ctl *ctl, const char *string) 422 { 423 unsigned int i; 424 unsigned int num_values = mixer_ctl_get_num_enums(ctl); 425 426 if (string == NULL) { 427 ALOGE("NULL enum value string passed to mixer_enum_string_to_value() for ctl %s", 428 mixer_ctl_get_name(ctl)); 429 return 0; 430 } 431 432 /* Search the enum strings for a particular one */ 433 for (i = 0; i < num_values; i++) { 434 if (strcmp(mixer_ctl_get_enum_string(ctl, i), string) == 0) 435 break; 436 } 437 if (i == num_values) { 438 ALOGE("unknown enum value string %s for ctl %s", 439 string, mixer_ctl_get_name(ctl)); 440 return 0; 441 } 442 return i; 443 } 444 445 static void start_tag(void *data, const XML_Char *tag_name, 446 const XML_Char **attr) 447 { 448 const XML_Char *attr_name = NULL; 449 const XML_Char *attr_id = NULL; 450 const XML_Char *attr_value = NULL; 451 struct config_parse_state *state = data; 452 struct audio_route *ar = state->ar; 453 unsigned int i; 454 unsigned int ctl_index; 455 struct mixer_ctl *ctl; 456 long value; 457 unsigned int id; 458 struct mixer_value mixer_value; 459 enum mixer_ctl_type type; 460 461 /* Get name, id and value attributes (these may be empty) */ 462 for (i = 0; attr[i]; i += 2) { 463 if (strcmp(attr[i], "name") == 0) 464 attr_name = attr[i + 1]; 465 if (strcmp(attr[i], "id") == 0) 466 attr_id = attr[i + 1]; 467 else if (strcmp(attr[i], "value") == 0) 468 attr_value = attr[i + 1]; 469 } 470 471 /* Look at tags */ 472 if (strcmp(tag_name, "path") == 0) { 473 if (attr_name == NULL) { 474 ALOGE("Unnamed path!"); 475 } else { 476 if (state->level == 1) { 477 /* top level path: create and stash the path */ 478 state->path = path_create(ar, (char *)attr_name); 479 } else { 480 /* nested path */ 481 struct mixer_path *sub_path = path_get_by_name(ar, attr_name); 482 if (!sub_path) { 483 ALOGE("unable to find sub path '%s'", attr_name); 484 } else { 485 path_add_path(ar, state->path, sub_path); 486 } 487 } 488 } 489 } 490 491 else if (strcmp(tag_name, "ctl") == 0) { 492 /* Obtain the mixer ctl and value */ 493 ctl = mixer_get_ctl_by_name(ar->mixer, attr_name); 494 if (ctl == NULL) { 495 ALOGE("Control '%s' doesn't exist - skipping", attr_name); 496 goto done; 497 } 498 499 switch (mixer_ctl_get_type(ctl)) { 500 case MIXER_CTL_TYPE_BOOL: 501 case MIXER_CTL_TYPE_INT: 502 value = strtol((char *)attr_value, NULL, 0); 503 break; 504 case MIXER_CTL_TYPE_BYTE: 505 value = (unsigned char) strtol((char *)attr_value, NULL, 16); 506 break; 507 case MIXER_CTL_TYPE_ENUM: 508 value = mixer_enum_string_to_value(ctl, (char *)attr_value); 509 break; 510 default: 511 value = 0; 512 break; 513 } 514 515 /* locate the mixer ctl in the list */ 516 for (ctl_index = 0; ctl_index < ar->num_mixer_ctls; ctl_index++) { 517 if (ar->mixer_state[ctl_index].ctl == ctl) 518 break; 519 } 520 521 if (state->level == 1) { 522 /* top level ctl (initial setting) */ 523 524 type = mixer_ctl_get_type(ctl); 525 if (is_supported_ctl_type(type)) { 526 /* apply the new value */ 527 if (attr_id) { 528 /* set only one value */ 529 id = atoi((char *)attr_id); 530 if (id < ar->mixer_state[ctl_index].num_values) 531 if (type == MIXER_CTL_TYPE_BYTE) 532 ar->mixer_state[ctl_index].new_value.bytes[id] = value; 533 else if (type == MIXER_CTL_TYPE_ENUM) 534 ar->mixer_state[ctl_index].new_value.enumerated[id] = value; 535 else 536 ar->mixer_state[ctl_index].new_value.integer[id] = value; 537 else 538 ALOGE("value id out of range for mixer ctl '%s'", 539 mixer_ctl_get_name(ctl)); 540 } else { 541 /* set all values the same */ 542 for (i = 0; i < ar->mixer_state[ctl_index].num_values; i++) 543 if (type == MIXER_CTL_TYPE_BYTE) 544 ar->mixer_state[ctl_index].new_value.bytes[i] = value; 545 else if (type == MIXER_CTL_TYPE_ENUM) 546 ar->mixer_state[ctl_index].new_value.enumerated[i] = value; 547 else 548 ar->mixer_state[ctl_index].new_value.integer[i] = value; 549 } 550 } 551 } else { 552 /* nested ctl (within a path) */ 553 mixer_value.ctl_index = ctl_index; 554 mixer_value.value = value; 555 if (attr_id) 556 mixer_value.index = atoi((char *)attr_id); 557 else 558 mixer_value.index = -1; 559 path_add_value(ar, state->path, &mixer_value); 560 } 561 } 562 563 done: 564 state->level++; 565 } 566 567 static void end_tag(void *data, const XML_Char *tag_name) 568 { 569 struct config_parse_state *state = data; 570 (void)tag_name; 571 572 state->level--; 573 } 574 575 static int alloc_mixer_state(struct audio_route *ar) 576 { 577 unsigned int i; 578 unsigned int num_values; 579 struct mixer_ctl *ctl; 580 enum mixer_ctl_type type; 581 582 ar->num_mixer_ctls = mixer_get_num_ctls(ar->mixer); 583 ar->mixer_state = calloc(ar->num_mixer_ctls, sizeof(struct mixer_state)); 584 if (!ar->mixer_state) 585 return -1; 586 587 for (i = 0; i < ar->num_mixer_ctls; i++) { 588 ctl = mixer_get_ctl(ar->mixer, i); 589 num_values = mixer_ctl_get_num_values(ctl); 590 591 ar->mixer_state[i].ctl = ctl; 592 ar->mixer_state[i].num_values = num_values; 593 594 /* Skip unsupported types that are not supported yet in XML */ 595 type = mixer_ctl_get_type(ctl); 596 597 if (!is_supported_ctl_type(type)) 598 continue; 599 600 size_t value_sz = sizeof_ctl_type(type); 601 ar->mixer_state[i].old_value.ptr = calloc(num_values, value_sz); 602 ar->mixer_state[i].new_value.ptr = calloc(num_values, value_sz); 603 ar->mixer_state[i].reset_value.ptr = calloc(num_values, value_sz); 604 605 if (type == MIXER_CTL_TYPE_ENUM) 606 ar->mixer_state[i].old_value.enumerated[0] = mixer_ctl_get_value(ctl, 0); 607 else 608 mixer_ctl_get_array(ctl, ar->mixer_state[i].old_value.ptr, num_values); 609 610 memcpy(ar->mixer_state[i].new_value.ptr, ar->mixer_state[i].old_value.ptr, 611 num_values * value_sz); 612 } 613 614 return 0; 615 } 616 617 static void free_mixer_state(struct audio_route *ar) 618 { 619 unsigned int i; 620 enum mixer_ctl_type type; 621 622 for (i = 0; i < ar->num_mixer_ctls; i++) { 623 type = mixer_ctl_get_type(ar->mixer_state[i].ctl); 624 if (!is_supported_ctl_type(type)) 625 continue; 626 627 free(ar->mixer_state[i].old_value.ptr); 628 free(ar->mixer_state[i].new_value.ptr); 629 free(ar->mixer_state[i].reset_value.ptr); 630 } 631 632 free(ar->mixer_state); 633 ar->mixer_state = NULL; 634 } 635 636 /* Update the mixer with any changed values */ 637 int audio_route_update_mixer(struct audio_route *ar) 638 { 639 unsigned int i; 640 unsigned int j; 641 struct mixer_ctl *ctl; 642 643 for (i = 0; i < ar->num_mixer_ctls; i++) { 644 unsigned int num_values = ar->mixer_state[i].num_values; 645 enum mixer_ctl_type type; 646 647 ctl = ar->mixer_state[i].ctl; 648 649 /* Skip unsupported types */ 650 type = mixer_ctl_get_type(ctl); 651 if (!is_supported_ctl_type(type)) 652 continue; 653 654 /* if the value has changed, update the mixer */ 655 bool changed = false; 656 if (type == MIXER_CTL_TYPE_BYTE) { 657 for (j = 0; j < num_values; j++) { 658 if (ar->mixer_state[i].old_value.bytes[j] != ar->mixer_state[i].new_value.bytes[j]) { 659 changed = true; 660 break; 661 } 662 } 663 } else if (type == MIXER_CTL_TYPE_ENUM) { 664 for (j = 0; j < num_values; j++) { 665 if (ar->mixer_state[i].old_value.enumerated[j] 666 != ar->mixer_state[i].new_value.enumerated[j]) { 667 changed = true; 668 break; 669 } 670 } 671 } else { 672 for (j = 0; j < num_values; j++) { 673 if (ar->mixer_state[i].old_value.integer[j] != ar->mixer_state[i].new_value.integer[j]) { 674 changed = true; 675 break; 676 } 677 } 678 } 679 if (changed) { 680 if (type == MIXER_CTL_TYPE_ENUM) 681 mixer_ctl_set_value(ctl, 0, ar->mixer_state[i].new_value.enumerated[0]); 682 else 683 mixer_ctl_set_array(ctl, ar->mixer_state[i].new_value.ptr, num_values); 684 685 size_t value_sz = sizeof_ctl_type(type); 686 memcpy(ar->mixer_state[i].old_value.ptr, ar->mixer_state[i].new_value.ptr, 687 num_values * value_sz); 688 } 689 } 690 691 return 0; 692 } 693 694 /* saves the current state of the mixer, for resetting all controls */ 695 static void save_mixer_state(struct audio_route *ar) 696 { 697 unsigned int i; 698 enum mixer_ctl_type type; 699 700 for (i = 0; i < ar->num_mixer_ctls; i++) { 701 type = mixer_ctl_get_type(ar->mixer_state[i].ctl); 702 if (!is_supported_ctl_type(type)) 703 continue; 704 705 size_t value_sz = sizeof_ctl_type(type); 706 memcpy(ar->mixer_state[i].reset_value.ptr, ar->mixer_state[i].new_value.ptr, 707 ar->mixer_state[i].num_values * value_sz); 708 } 709 } 710 711 /* Reset the audio routes back to the initial state */ 712 void audio_route_reset(struct audio_route *ar) 713 { 714 unsigned int i; 715 enum mixer_ctl_type type; 716 717 /* load all of the saved values */ 718 for (i = 0; i < ar->num_mixer_ctls; i++) { 719 type = mixer_ctl_get_type(ar->mixer_state[i].ctl); 720 if (!is_supported_ctl_type(type)) 721 continue; 722 723 size_t value_sz = sizeof_ctl_type(type); 724 memcpy(ar->mixer_state[i].new_value.ptr, ar->mixer_state[i].reset_value.ptr, 725 ar->mixer_state[i].num_values * value_sz); 726 } 727 } 728 729 /* Apply an audio route path by name */ 730 int audio_route_apply_path(struct audio_route *ar, const char *name) 731 { 732 struct mixer_path *path; 733 734 if (!ar) { 735 ALOGE("invalid audio_route"); 736 return -1; 737 } 738 739 path = path_get_by_name(ar, name); 740 if (!path) { 741 ALOGE("unable to find path '%s'", name); 742 return -1; 743 } 744 745 path_apply(ar, path); 746 747 return 0; 748 } 749 750 /* Reset an audio route path by name */ 751 int audio_route_reset_path(struct audio_route *ar, const char *name) 752 { 753 struct mixer_path *path; 754 755 if (!ar) { 756 ALOGE("invalid audio_route"); 757 return -1; 758 } 759 760 path = path_get_by_name(ar, name); 761 if (!path) { 762 ALOGE("unable to find path '%s'", name); 763 return -1; 764 } 765 766 path_reset(ar, path); 767 768 return 0; 769 } 770 771 /* 772 * Operates on the specified path .. controls will be updated in the 773 * order listed in the XML file 774 */ 775 static int audio_route_update_path(struct audio_route *ar, const char *name, bool reverse) 776 { 777 struct mixer_path *path; 778 int32_t i, end; 779 unsigned int j; 780 781 if (!ar) { 782 ALOGE("invalid audio_route"); 783 return -1; 784 } 785 786 path = path_get_by_name(ar, name); 787 if (!path) { 788 ALOGE("unable to find path '%s'", name); 789 return -1; 790 } 791 792 i = reverse ? (path->length - 1) : 0; 793 end = reverse ? -1 : (int32_t)path->length; 794 795 while (i != end) { 796 unsigned int ctl_index; 797 enum mixer_ctl_type type; 798 799 ctl_index = path->setting[i].ctl_index; 800 801 struct mixer_state * ms = &ar->mixer_state[ctl_index]; 802 803 type = mixer_ctl_get_type(ms->ctl); 804 if (!is_supported_ctl_type(type)) { 805 continue; 806 } 807 808 size_t value_sz = sizeof_ctl_type(type); 809 /* if any value has changed, update the mixer */ 810 for (j = 0; j < ms->num_values; j++) { 811 if (type == MIXER_CTL_TYPE_BYTE) { 812 if (ms->old_value.bytes[j] != ms->new_value.bytes[j]) { 813 mixer_ctl_set_array(ms->ctl, ms->new_value.bytes, ms->num_values); 814 memcpy(ms->old_value.bytes, ms->new_value.bytes, ms->num_values * value_sz); 815 break; 816 } 817 } else if (type == MIXER_CTL_TYPE_ENUM) { 818 if (ms->old_value.enumerated[j] != ms->new_value.enumerated[j]) { 819 mixer_ctl_set_value(ms->ctl, 0, ms->new_value.enumerated[0]); 820 memcpy(ms->old_value.enumerated, ms->new_value.enumerated, 821 ms->num_values * value_sz); 822 break; 823 } 824 } else if (ms->old_value.integer[j] != ms->new_value.integer[j]) { 825 mixer_ctl_set_array(ms->ctl, ms->new_value.integer, ms->num_values); 826 memcpy(ms->old_value.integer, ms->new_value.integer, ms->num_values * value_sz); 827 break; 828 } 829 } 830 831 i = reverse ? (i - 1) : (i + 1); 832 } 833 return 0; 834 } 835 836 int audio_route_apply_and_update_path(struct audio_route *ar, const char *name) 837 { 838 if (audio_route_apply_path(ar, name) < 0) { 839 return -1; 840 } 841 return audio_route_update_path(ar, name, false /*reverse*/); 842 } 843 844 int audio_route_reset_and_update_path(struct audio_route *ar, const char *name) 845 { 846 if (audio_route_reset_path(ar, name) < 0) { 847 return -1; 848 } 849 return audio_route_update_path(ar, name, true /*reverse*/); 850 } 851 852 struct audio_route *audio_route_init(unsigned int card, const char *xml_path) 853 { 854 struct config_parse_state state; 855 XML_Parser parser; 856 FILE *file; 857 int bytes_read; 858 void *buf; 859 struct audio_route *ar; 860 861 ar = calloc(1, sizeof(struct audio_route)); 862 if (!ar) 863 goto err_calloc; 864 865 ar->mixer = mixer_open(card); 866 if (!ar->mixer) { 867 ALOGE("Unable to open the mixer, aborting."); 868 goto err_mixer_open; 869 } 870 871 ar->mixer_path = NULL; 872 ar->mixer_path_size = 0; 873 ar->num_mixer_paths = 0; 874 875 /* allocate space for and read current mixer settings */ 876 if (alloc_mixer_state(ar) < 0) 877 goto err_mixer_state; 878 879 /* use the default XML path if none is provided */ 880 if (xml_path == NULL) 881 xml_path = MIXER_XML_PATH; 882 883 file = fopen(xml_path, "r"); 884 885 if (!file) { 886 ALOGE("Failed to open %s: %s", xml_path, strerror(errno)); 887 goto err_fopen; 888 } 889 890 parser = XML_ParserCreate(NULL); 891 if (!parser) { 892 ALOGE("Failed to create XML parser"); 893 goto err_parser_create; 894 } 895 896 memset(&state, 0, sizeof(state)); 897 state.ar = ar; 898 XML_SetUserData(parser, &state); 899 XML_SetElementHandler(parser, start_tag, end_tag); 900 901 for (;;) { 902 buf = XML_GetBuffer(parser, BUF_SIZE); 903 if (buf == NULL) 904 goto err_parse; 905 906 bytes_read = fread(buf, 1, BUF_SIZE, file); 907 if (bytes_read < 0) 908 goto err_parse; 909 910 if (XML_ParseBuffer(parser, bytes_read, 911 bytes_read == 0) == XML_STATUS_ERROR) { 912 ALOGE("Error in mixer xml (%s)", MIXER_XML_PATH); 913 goto err_parse; 914 } 915 916 if (bytes_read == 0) 917 break; 918 } 919 920 /* apply the initial mixer values, and save them so we can reset the 921 mixer to the original values */ 922 audio_route_update_mixer(ar); 923 save_mixer_state(ar); 924 925 XML_ParserFree(parser); 926 fclose(file); 927 return ar; 928 929 err_parse: 930 path_free(ar); 931 XML_ParserFree(parser); 932 err_parser_create: 933 fclose(file); 934 err_fopen: 935 free_mixer_state(ar); 936 err_mixer_state: 937 mixer_close(ar->mixer); 938 err_mixer_open: 939 free(ar); 940 ar = NULL; 941 err_calloc: 942 return NULL; 943 } 944 945 void audio_route_free(struct audio_route *ar) 946 { 947 free_mixer_state(ar); 948 mixer_close(ar->mixer); 949 path_free(ar); 950 free(ar); 951 } 952
