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