1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "offload_effect_api" 18 //#define LOG_NDEBUG 0 19 20 #include <stdio.h> 21 #include <errno.h> 22 #include <stdbool.h> 23 24 #include <cutils/log.h> 25 #include <tinyalsa/asoundlib.h> 26 #include <sound/audio_effects.h> 27 28 #include "effect_api.h" 29 30 #define ARRAY_SIZE(array) (sizeof array / sizeof array[0]) 31 32 #define OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL 19 33 const int map_eq_opensl_preset_2_offload_preset[] = { 34 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL, /* Normal Preset */ 35 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+1, /* Classical Preset */ 36 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+2, /* Dance Preset */ 37 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+3, /* Flat Preset */ 38 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+4, /* Folk Preset */ 39 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+5, /* Heavy Metal Preset */ 40 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+6, /* Hip Hop Preset */ 41 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+7, /* Jazz Preset */ 42 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+8, /* Pop Preset */ 43 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+9, /* Rock Preset */ 44 OFFLOAD_PRESET_START_OFFSET_FOR_OPENSL+10 /* FX Booster */ 45 }; 46 47 const int map_reverb_opensl_preset_2_offload_preset 48 [NUM_OSL_REVERB_PRESETS_SUPPORTED][2] = { 49 {1, 15}, 50 {2, 16}, 51 {3, 17}, 52 {4, 18}, 53 {5, 3}, 54 {6, 20} 55 }; 56 57 int offload_update_mixer_and_effects_ctl(int card, int device_id, 58 struct mixer *mixer, 59 struct mixer_ctl *ctl) 60 { 61 char mixer_string[128]; 62 63 snprintf(mixer_string, sizeof(mixer_string), 64 "%s %d", "Audio Effects Config", device_id); 65 ALOGV("%s: mixer_string: %s", __func__, mixer_string); 66 mixer = mixer_open(card); 67 if (!mixer) { 68 ALOGE("Failed to open mixer"); 69 ctl = NULL; 70 return -EINVAL; 71 } else { 72 ctl = mixer_get_ctl_by_name(mixer, mixer_string); 73 if (!ctl) { 74 ALOGE("mixer_get_ctl_by_name failed"); 75 mixer_close(mixer); 76 mixer = NULL; 77 return -EINVAL; 78 } 79 } 80 ALOGV("mixer: %p, ctl: %p", mixer, ctl); 81 return 0; 82 } 83 84 void offload_close_mixer(struct mixer *mixer) 85 { 86 mixer_close(mixer); 87 } 88 89 void offload_bassboost_set_device(struct bass_boost_params *bassboost, 90 uint32_t device) 91 { 92 ALOGV("%s", __func__); 93 bassboost->device = device; 94 } 95 96 void offload_bassboost_set_enable_flag(struct bass_boost_params *bassboost, 97 bool enable) 98 { 99 ALOGV("%s", __func__); 100 bassboost->enable_flag = enable; 101 } 102 103 int offload_bassboost_get_enable_flag(struct bass_boost_params *bassboost) 104 { 105 ALOGV("%s", __func__); 106 return bassboost->enable_flag; 107 } 108 109 void offload_bassboost_set_strength(struct bass_boost_params *bassboost, 110 int strength) 111 { 112 ALOGV("%s", __func__); 113 bassboost->strength = strength; 114 } 115 116 void offload_bassboost_set_mode(struct bass_boost_params *bassboost, 117 int mode) 118 { 119 ALOGV("%s", __func__); 120 bassboost->mode = mode; 121 } 122 123 int offload_bassboost_send_params(struct mixer_ctl *ctl, 124 struct bass_boost_params *bassboost, 125 unsigned param_send_flags) 126 { 127 int param_values[128] = {0}; 128 int *p_param_values = param_values; 129 130 ALOGV("%s", __func__); 131 *p_param_values++ = BASS_BOOST_MODULE; 132 *p_param_values++ = bassboost->device; 133 *p_param_values++ = 0; /* num of commands*/ 134 if (param_send_flags & OFFLOAD_SEND_BASSBOOST_ENABLE_FLAG) { 135 *p_param_values++ = BASS_BOOST_ENABLE; 136 *p_param_values++ = CONFIG_SET; 137 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 138 *p_param_values++ = BASS_BOOST_ENABLE_PARAM_LEN; 139 *p_param_values++ = bassboost->enable_flag; 140 param_values[2] += 1; 141 } 142 if (param_send_flags & OFFLOAD_SEND_BASSBOOST_STRENGTH) { 143 *p_param_values++ = BASS_BOOST_STRENGTH; 144 *p_param_values++ = CONFIG_SET; 145 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 146 *p_param_values++ = BASS_BOOST_STRENGTH_PARAM_LEN; 147 *p_param_values++ = bassboost->strength; 148 param_values[2] += 1; 149 } 150 if (param_send_flags & OFFLOAD_SEND_BASSBOOST_MODE) { 151 *p_param_values++ = BASS_BOOST_MODE; 152 *p_param_values++ = CONFIG_SET; 153 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 154 *p_param_values++ = BASS_BOOST_MODE_PARAM_LEN; 155 *p_param_values++ = bassboost->mode; 156 param_values[2] += 1; 157 } 158 159 if (param_values[2] && ctl) 160 mixer_ctl_set_array(ctl, param_values, ARRAY_SIZE(param_values)); 161 162 return 0; 163 } 164 165 void offload_virtualizer_set_device(struct virtualizer_params *virtualizer, 166 uint32_t device) 167 { 168 ALOGV("%s", __func__); 169 virtualizer->device = device; 170 } 171 172 void offload_virtualizer_set_enable_flag(struct virtualizer_params *virtualizer, 173 bool enable) 174 { 175 ALOGV("%s", __func__); 176 virtualizer->enable_flag = enable; 177 } 178 179 int offload_virtualizer_get_enable_flag(struct virtualizer_params *virtualizer) 180 { 181 ALOGV("%s", __func__); 182 return virtualizer->enable_flag; 183 } 184 185 void offload_virtualizer_set_strength(struct virtualizer_params *virtualizer, 186 int strength) 187 { 188 ALOGV("%s", __func__); 189 virtualizer->strength = strength; 190 } 191 192 void offload_virtualizer_set_out_type(struct virtualizer_params *virtualizer, 193 int out_type) 194 { 195 ALOGV("%s", __func__); 196 virtualizer->out_type = out_type; 197 } 198 199 void offload_virtualizer_set_gain_adjust(struct virtualizer_params *virtualizer, 200 int gain_adjust) 201 { 202 ALOGV("%s", __func__); 203 virtualizer->gain_adjust = gain_adjust; 204 } 205 206 int offload_virtualizer_send_params(struct mixer_ctl *ctl, 207 struct virtualizer_params *virtualizer, 208 unsigned param_send_flags) 209 { 210 int param_values[128] = {0}; 211 int *p_param_values = param_values; 212 213 ALOGV("%s", __func__); 214 *p_param_values++ = VIRTUALIZER_MODULE; 215 *p_param_values++ = virtualizer->device; 216 *p_param_values++ = 0; /* num of commands*/ 217 if (param_send_flags & OFFLOAD_SEND_VIRTUALIZER_ENABLE_FLAG) { 218 *p_param_values++ = VIRTUALIZER_ENABLE; 219 *p_param_values++ = CONFIG_SET; 220 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 221 *p_param_values++ = VIRTUALIZER_ENABLE_PARAM_LEN; 222 *p_param_values++ = virtualizer->enable_flag; 223 param_values[2] += 1; 224 } 225 if (param_send_flags & OFFLOAD_SEND_VIRTUALIZER_STRENGTH) { 226 *p_param_values++ = VIRTUALIZER_STRENGTH; 227 *p_param_values++ = CONFIG_SET; 228 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 229 *p_param_values++ = VIRTUALIZER_STRENGTH_PARAM_LEN; 230 *p_param_values++ = virtualizer->strength; 231 param_values[2] += 1; 232 } 233 if (param_send_flags & OFFLOAD_SEND_VIRTUALIZER_OUT_TYPE) { 234 *p_param_values++ = VIRTUALIZER_OUT_TYPE; 235 *p_param_values++ = CONFIG_SET; 236 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 237 *p_param_values++ = VIRTUALIZER_OUT_TYPE_PARAM_LEN; 238 *p_param_values++ = virtualizer->out_type; 239 param_values[2] += 1; 240 } 241 if (param_send_flags & OFFLOAD_SEND_VIRTUALIZER_GAIN_ADJUST) { 242 *p_param_values++ = VIRTUALIZER_GAIN_ADJUST; 243 *p_param_values++ = CONFIG_SET; 244 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 245 *p_param_values++ = VIRTUALIZER_GAIN_ADJUST_PARAM_LEN; 246 *p_param_values++ = virtualizer->gain_adjust; 247 param_values[2] += 1; 248 } 249 250 if (param_values[2] && ctl) 251 mixer_ctl_set_array(ctl, param_values, ARRAY_SIZE(param_values)); 252 253 return 0; 254 } 255 256 void offload_eq_set_device(struct eq_params *eq, uint32_t device) 257 { 258 ALOGV("%s", __func__); 259 eq->device = device; 260 } 261 262 void offload_eq_set_enable_flag(struct eq_params *eq, bool enable) 263 { 264 ALOGV("%s", __func__); 265 eq->enable_flag = enable; 266 } 267 268 int offload_eq_get_enable_flag(struct eq_params *eq) 269 { 270 ALOGV("%s", __func__); 271 return eq->enable_flag; 272 } 273 274 void offload_eq_set_preset(struct eq_params *eq, int preset) 275 { 276 ALOGV("%s", __func__); 277 eq->config.preset_id = preset; 278 eq->config.eq_pregain = Q27_UNITY; 279 } 280 281 void offload_eq_set_bands_level(struct eq_params *eq, int num_bands, 282 const uint16_t *band_freq_list, 283 int *band_gain_list) 284 { 285 int i; 286 ALOGV("%s", __func__); 287 eq->config.num_bands = num_bands; 288 for (i=0; i<num_bands; i++) { 289 eq->per_band_cfg[i].band_idx = i; 290 eq->per_band_cfg[i].filter_type = EQ_BAND_BOOST; 291 eq->per_band_cfg[i].freq_millihertz = band_freq_list[i] * 1000; 292 eq->per_band_cfg[i].gain_millibels = band_gain_list[i] * 100; 293 eq->per_band_cfg[i].quality_factor = Q8_UNITY; 294 } 295 } 296 297 int offload_eq_send_params(struct mixer_ctl *ctl, struct eq_params *eq, 298 unsigned param_send_flags) 299 { 300 int param_values[128] = {0}; 301 int *p_param_values = param_values; 302 uint32_t i; 303 304 ALOGV("%s", __func__); 305 if (eq->config.preset_id < -1 ) { 306 ALOGV("No Valid preset to set"); 307 return 0; 308 } 309 *p_param_values++ = EQ_MODULE; 310 *p_param_values++ = eq->device; 311 *p_param_values++ = 0; /* num of commands*/ 312 if (param_send_flags & OFFLOAD_SEND_EQ_ENABLE_FLAG) { 313 *p_param_values++ = EQ_ENABLE; 314 *p_param_values++ = CONFIG_SET; 315 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 316 *p_param_values++ = EQ_ENABLE_PARAM_LEN; 317 *p_param_values++ = eq->enable_flag; 318 param_values[2] += 1; 319 } 320 if (param_send_flags & OFFLOAD_SEND_EQ_PRESET) { 321 *p_param_values++ = EQ_CONFIG; 322 *p_param_values++ = CONFIG_SET; 323 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 324 *p_param_values++ = EQ_CONFIG_PARAM_LEN; 325 *p_param_values++ = eq->config.eq_pregain; 326 *p_param_values++ = 327 map_eq_opensl_preset_2_offload_preset[eq->config.preset_id]; 328 *p_param_values++ = 0; 329 param_values[2] += 1; 330 } 331 if (param_send_flags & OFFLOAD_SEND_EQ_BANDS_LEVEL) { 332 *p_param_values++ = EQ_CONFIG; 333 *p_param_values++ = CONFIG_SET; 334 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 335 *p_param_values++ = EQ_CONFIG_PARAM_LEN + 336 eq->config.num_bands * EQ_CONFIG_PER_BAND_PARAM_LEN; 337 *p_param_values++ = eq->config.eq_pregain; 338 *p_param_values++ = CUSTOM_OPENSL_PRESET; 339 *p_param_values++ = eq->config.num_bands; 340 for (i=0; i<eq->config.num_bands; i++) { 341 *p_param_values++ = eq->per_band_cfg[i].band_idx; 342 *p_param_values++ = eq->per_band_cfg[i].filter_type; 343 *p_param_values++ = eq->per_band_cfg[i].freq_millihertz; 344 *p_param_values++ = eq->per_band_cfg[i].gain_millibels; 345 *p_param_values++ = eq->per_band_cfg[i].quality_factor; 346 } 347 param_values[2] += 1; 348 } 349 350 if (param_values[2] && ctl) 351 mixer_ctl_set_array(ctl, param_values, ARRAY_SIZE(param_values)); 352 353 return 0; 354 } 355 356 void offload_reverb_set_device(struct reverb_params *reverb, uint32_t device) 357 { 358 ALOGV("%s", __func__); 359 reverb->device = device; 360 } 361 362 void offload_reverb_set_enable_flag(struct reverb_params *reverb, bool enable) 363 { 364 ALOGV("%s", __func__); 365 reverb->enable_flag = enable; 366 } 367 368 int offload_reverb_get_enable_flag(struct reverb_params *reverb) 369 { 370 ALOGV("%s", __func__); 371 return reverb->enable_flag; 372 } 373 374 void offload_reverb_set_mode(struct reverb_params *reverb, int mode) 375 { 376 ALOGV("%s", __func__); 377 reverb->mode = mode; 378 } 379 380 void offload_reverb_set_preset(struct reverb_params *reverb, int preset) 381 { 382 ALOGV("%s", __func__); 383 if (preset && (preset <= NUM_OSL_REVERB_PRESETS_SUPPORTED)) 384 reverb->preset = map_reverb_opensl_preset_2_offload_preset[preset-1][1]; 385 } 386 387 void offload_reverb_set_wet_mix(struct reverb_params *reverb, int wet_mix) 388 { 389 ALOGV("%s", __func__); 390 reverb->wet_mix = wet_mix; 391 } 392 393 void offload_reverb_set_gain_adjust(struct reverb_params *reverb, 394 int gain_adjust) 395 { 396 ALOGV("%s", __func__); 397 reverb->gain_adjust = gain_adjust; 398 } 399 400 void offload_reverb_set_room_level(struct reverb_params *reverb, int room_level) 401 { 402 ALOGV("%s", __func__); 403 reverb->room_level = room_level; 404 } 405 406 void offload_reverb_set_room_hf_level(struct reverb_params *reverb, 407 int room_hf_level) 408 { 409 ALOGV("%s", __func__); 410 reverb->room_hf_level = room_hf_level; 411 } 412 413 void offload_reverb_set_decay_time(struct reverb_params *reverb, int decay_time) 414 { 415 ALOGV("%s", __func__); 416 reverb->decay_time = decay_time; 417 } 418 419 void offload_reverb_set_decay_hf_ratio(struct reverb_params *reverb, 420 int decay_hf_ratio) 421 { 422 ALOGV("%s", __func__); 423 reverb->decay_hf_ratio = decay_hf_ratio; 424 } 425 426 void offload_reverb_set_reflections_level(struct reverb_params *reverb, 427 int reflections_level) 428 { 429 ALOGV("%s", __func__); 430 reverb->reflections_level = reflections_level; 431 } 432 433 void offload_reverb_set_reflections_delay(struct reverb_params *reverb, 434 int reflections_delay) 435 { 436 ALOGV("%s", __func__); 437 reverb->reflections_delay = reflections_delay; 438 } 439 440 void offload_reverb_set_reverb_level(struct reverb_params *reverb, 441 int reverb_level) 442 { 443 ALOGV("%s", __func__); 444 reverb->level = reverb_level; 445 } 446 447 void offload_reverb_set_delay(struct reverb_params *reverb, int delay) 448 { 449 ALOGV("%s", __func__); 450 reverb->delay = delay; 451 } 452 453 void offload_reverb_set_diffusion(struct reverb_params *reverb, int diffusion) 454 { 455 ALOGV("%s", __func__); 456 reverb->diffusion = diffusion; 457 } 458 459 void offload_reverb_set_density(struct reverb_params *reverb, int density) 460 { 461 ALOGV("%s", __func__); 462 reverb->density = density; 463 } 464 465 int offload_reverb_send_params(struct mixer_ctl *ctl, 466 struct reverb_params *reverb, 467 unsigned param_send_flags) 468 { 469 int param_values[128] = {0}; 470 int *p_param_values = param_values; 471 472 ALOGV("%s", __func__); 473 *p_param_values++ = REVERB_MODULE; 474 *p_param_values++ = reverb->device; 475 *p_param_values++ = 0; /* num of commands*/ 476 477 if (param_send_flags & OFFLOAD_SEND_REVERB_ENABLE_FLAG) { 478 *p_param_values++ = REVERB_ENABLE; 479 *p_param_values++ = CONFIG_SET; 480 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 481 *p_param_values++ = REVERB_ENABLE_PARAM_LEN; 482 *p_param_values++ = reverb->enable_flag; 483 param_values[2] += 1; 484 } 485 if (param_send_flags & OFFLOAD_SEND_REVERB_MODE) { 486 *p_param_values++ = REVERB_MODE; 487 *p_param_values++ = CONFIG_SET; 488 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 489 *p_param_values++ = REVERB_MODE_PARAM_LEN; 490 *p_param_values++ = reverb->mode; 491 param_values[2] += 1; 492 } 493 if (param_send_flags & OFFLOAD_SEND_REVERB_PRESET) { 494 *p_param_values++ = REVERB_PRESET; 495 *p_param_values++ = CONFIG_SET; 496 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 497 *p_param_values++ = REVERB_PRESET_PARAM_LEN; 498 *p_param_values++ = reverb->preset; 499 param_values[2] += 1; 500 } 501 if (param_send_flags & OFFLOAD_SEND_REVERB_WET_MIX) { 502 *p_param_values++ = REVERB_WET_MIX; 503 *p_param_values++ = CONFIG_SET; 504 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 505 *p_param_values++ = REVERB_WET_MIX_PARAM_LEN; 506 *p_param_values++ = reverb->wet_mix; 507 param_values[2] += 1; 508 } 509 if (param_send_flags & OFFLOAD_SEND_REVERB_GAIN_ADJUST) { 510 *p_param_values++ = REVERB_GAIN_ADJUST; 511 *p_param_values++ = CONFIG_SET; 512 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 513 *p_param_values++ = REVERB_GAIN_ADJUST_PARAM_LEN; 514 *p_param_values++ = reverb->gain_adjust; 515 param_values[2] += 1; 516 } 517 if (param_send_flags & OFFLOAD_SEND_REVERB_ROOM_LEVEL) { 518 *p_param_values++ = REVERB_ROOM_LEVEL; 519 *p_param_values++ = CONFIG_SET; 520 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 521 *p_param_values++ = REVERB_ROOM_LEVEL_PARAM_LEN; 522 *p_param_values++ = reverb->room_level; 523 param_values[2] += 1; 524 } 525 if (param_send_flags & OFFLOAD_SEND_REVERB_ROOM_HF_LEVEL) { 526 *p_param_values++ = REVERB_ROOM_HF_LEVEL; 527 *p_param_values++ = CONFIG_SET; 528 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 529 *p_param_values++ = REVERB_ROOM_HF_LEVEL_PARAM_LEN; 530 *p_param_values++ = reverb->room_hf_level; 531 param_values[2] += 1; 532 } 533 if (param_send_flags & OFFLOAD_SEND_REVERB_DECAY_TIME) { 534 *p_param_values++ = REVERB_DECAY_TIME; 535 *p_param_values++ = CONFIG_SET; 536 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 537 *p_param_values++ = REVERB_DECAY_TIME_PARAM_LEN; 538 *p_param_values++ = reverb->decay_time; 539 param_values[2] += 1; 540 } 541 if (param_send_flags & OFFLOAD_SEND_REVERB_DECAY_HF_RATIO) { 542 *p_param_values++ = REVERB_DECAY_HF_RATIO; 543 *p_param_values++ = CONFIG_SET; 544 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 545 *p_param_values++ = REVERB_DECAY_HF_RATIO_PARAM_LEN; 546 *p_param_values++ = reverb->decay_hf_ratio; 547 param_values[2] += 1; 548 } 549 if (param_send_flags & OFFLOAD_SEND_REVERB_REFLECTIONS_LEVEL) { 550 *p_param_values++ = REVERB_REFLECTIONS_LEVEL; 551 *p_param_values++ = CONFIG_SET; 552 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 553 *p_param_values++ = REVERB_REFLECTIONS_LEVEL_PARAM_LEN; 554 *p_param_values++ = reverb->reflections_level; 555 param_values[2] += 1; 556 } 557 if (param_send_flags & OFFLOAD_SEND_REVERB_REFLECTIONS_DELAY) { 558 *p_param_values++ = REVERB_REFLECTIONS_DELAY; 559 *p_param_values++ = CONFIG_SET; 560 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 561 *p_param_values++ = REVERB_REFLECTIONS_DELAY_PARAM_LEN; 562 *p_param_values++ = reverb->reflections_delay; 563 param_values[2] += 1; 564 } 565 if (param_send_flags & OFFLOAD_SEND_REVERB_LEVEL) { 566 *p_param_values++ = REVERB_LEVEL; 567 *p_param_values++ = CONFIG_SET; 568 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 569 *p_param_values++ = REVERB_LEVEL_PARAM_LEN; 570 *p_param_values++ = reverb->level; 571 param_values[2] += 1; 572 } 573 if (param_send_flags & OFFLOAD_SEND_REVERB_DELAY) { 574 *p_param_values++ = REVERB_DELAY; 575 *p_param_values++ = CONFIG_SET; 576 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 577 *p_param_values++ = REVERB_DELAY_PARAM_LEN; 578 *p_param_values++ = reverb->delay; 579 param_values[2] += 1; 580 } 581 if (param_send_flags & OFFLOAD_SEND_REVERB_DIFFUSION) { 582 *p_param_values++ = REVERB_DIFFUSION; 583 *p_param_values++ = CONFIG_SET; 584 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 585 *p_param_values++ = REVERB_DIFFUSION_PARAM_LEN; 586 *p_param_values++ = reverb->diffusion; 587 param_values[2] += 1; 588 } 589 if (param_send_flags & OFFLOAD_SEND_REVERB_DENSITY) { 590 *p_param_values++ = REVERB_DENSITY; 591 *p_param_values++ = CONFIG_SET; 592 *p_param_values++ = 0; /* start offset if param size if greater than 128 */ 593 *p_param_values++ = REVERB_DENSITY_PARAM_LEN; 594 *p_param_values++ = reverb->density; 595 param_values[2] += 1; 596 } 597 598 if (param_values[2] && ctl) 599 mixer_ctl_set_array(ctl, param_values, ARRAY_SIZE(param_values)); 600 601 return 0; 602 } 603
