1/* 2 * Copyright (C) 2010 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 18#include "sles_allinclusive.h" 19#include "math.h" 20#include "utils/RefBase.h" 21#include "utils/String16.h" 22 23#include <system/audio_effects/effect_bassboost.h> 24#include <system/audio_effects/effect_equalizer.h> 25#include <system/audio_effects/effect_environmentalreverb.h> 26#include <system/audio_effects/effect_presetreverb.h> 27#include <system/audio_effects/effect_virtualizer.h> 28 29#include <system/audio_effects/effect_aec.h> 30#include <system/audio_effects/effect_agc.h> 31#include <system/audio_effects/effect_ns.h> 32 33#include <system/audio.h> 34 35static const int EQUALIZER_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t) 36 + EFFECT_STRING_LEN_MAX; 37 38static const int BASSBOOST_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t); 39 40static const int VIRTUALIZER_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t); 41 42static const int ENVREVERB_PARAM_SIZE_MAX_SINGLE = sizeof(effect_param_t) + 2 * sizeof(int32_t); 43 44static const int ENVREVERB_PARAM_SIZE_MAX_ALL = sizeof(effect_param_t) + sizeof(int32_t) 45 + sizeof(s_reverb_settings); 46 47static const int PRESETREVERB_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t); 48 49static inline SLuint32 KEY_FROM_GUID(SLInterfaceID pUuid) { 50 return pUuid->time_low; 51} 52 53 54//----------------------------------------------------------------------------- 55static 56uint32_t eq_paramSize(int32_t param) { 57 uint32_t size; 58 59 switch (param) { 60 case EQ_PARAM_NUM_BANDS: 61 case EQ_PARAM_LEVEL_RANGE: 62 case EQ_PARAM_CUR_PRESET: 63 case EQ_PARAM_GET_NUM_OF_PRESETS: 64 size = sizeof(int32_t); 65 break; 66 case EQ_PARAM_BAND_LEVEL: 67 case EQ_PARAM_CENTER_FREQ: 68 case EQ_PARAM_BAND_FREQ_RANGE: 69 case EQ_PARAM_GET_BAND: 70 case EQ_PARAM_GET_PRESET_NAME: 71 size = 2 * sizeof(int32_t); 72 break; 73 default: 74 size = 2 * sizeof(int32_t); 75 SL_LOGE("Trying to use an unknown EQ parameter %d", param); 76 break; 77 } 78 return size; 79} 80 81static 82uint32_t eq_valueSize(int32_t param) { 83 uint32_t size; 84 85 switch (param) { 86 case EQ_PARAM_NUM_BANDS: 87 case EQ_PARAM_CUR_PRESET: 88 case EQ_PARAM_GET_NUM_OF_PRESETS: 89 case EQ_PARAM_BAND_LEVEL: 90 case EQ_PARAM_GET_BAND: 91 size = sizeof(int16_t); 92 break; 93 case EQ_PARAM_LEVEL_RANGE: 94 size = 2 * sizeof(int16_t); 95 break; 96 case EQ_PARAM_CENTER_FREQ: 97 size = sizeof(int32_t); 98 break; 99 case EQ_PARAM_BAND_FREQ_RANGE: 100 size = 2 * sizeof(int32_t); 101 break; 102 case EQ_PARAM_GET_PRESET_NAME: 103 size = EFFECT_STRING_LEN_MAX; 104 break; 105 default: 106 size = sizeof(int32_t); 107 SL_LOGE("Trying to access an unknown EQ parameter %d", param); 108 break; 109 } 110 return size; 111} 112 113//----------------------------------------------------------------------------- 114/** 115 * returns the size in bytes of the value of each bass boost parameter 116 */ 117static 118uint32_t bb_valueSize(int32_t param) { 119 uint32_t size; 120 121 switch (param) { 122 case BASSBOOST_PARAM_STRENGTH_SUPPORTED: 123 size = sizeof(int32_t); 124 break; 125 case BASSBOOST_PARAM_STRENGTH: 126 size = sizeof(int16_t); 127 break; 128 default: 129 size = sizeof(int32_t); 130 SL_LOGE("Trying to access an unknown BassBoost parameter %d", param); 131 break; 132 } 133 134 return size; 135} 136 137//----------------------------------------------------------------------------- 138/** 139 * returns the size in bytes of the value of each virtualizer parameter 140 */ 141static 142uint32_t virt_valueSize(int32_t param) { 143 uint32_t size; 144 145 switch (param) { 146 case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED: 147 size = sizeof(int32_t); 148 break; 149 case VIRTUALIZER_PARAM_STRENGTH: 150 size = sizeof(int16_t); 151 break; 152 default: 153 size = sizeof(int32_t); 154 SL_LOGE("Trying to access an unknown Virtualizer parameter %d", param); 155 break; 156 } 157 158 return size; 159} 160 161//----------------------------------------------------------------------------- 162/** 163 * returns the size in bytes of the value of each environmental reverb parameter 164 */ 165static 166uint32_t erev_valueSize(int32_t param) { 167 uint32_t size; 168 169 switch (param) { 170 case REVERB_PARAM_ROOM_LEVEL: 171 case REVERB_PARAM_ROOM_HF_LEVEL: 172 case REVERB_PARAM_REFLECTIONS_LEVEL: 173 case REVERB_PARAM_REVERB_LEVEL: 174 size = sizeof(int16_t); // millibel 175 break; 176 case REVERB_PARAM_DECAY_TIME: 177 case REVERB_PARAM_REFLECTIONS_DELAY: 178 case REVERB_PARAM_REVERB_DELAY: 179 size = sizeof(uint32_t); // milliseconds 180 break; 181 case REVERB_PARAM_DECAY_HF_RATIO: 182 case REVERB_PARAM_DIFFUSION: 183 case REVERB_PARAM_DENSITY: 184 size = sizeof(int16_t); // permille 185 break; 186 case REVERB_PARAM_PROPERTIES: 187 size = sizeof(s_reverb_settings); // struct of all reverb properties 188 break; 189 default: 190 size = sizeof(int32_t); 191 SL_LOGE("Trying to access an unknown Environmental Reverb parameter %d", param); 192 break; 193 } 194 195 return size; 196} 197 198//----------------------------------------------------------------------------- 199android::status_t android_eq_getParam(const android::sp<android::AudioEffect>& pFx, 200 int32_t param, int32_t param2, void *pValue) 201{ 202 android::status_t status; 203 uint32_t buf32[(EQUALIZER_PARAM_SIZE_MAX - 1) / sizeof(uint32_t) + 1]; 204 effect_param_t *p = (effect_param_t *)buf32; 205 206 p->psize = eq_paramSize(param); 207 *(int32_t *)p->data = param; 208 if (p->psize == 2 * sizeof(int32_t)) { 209 *((int32_t *)p->data + 1) = param2; 210 } 211 p->vsize = eq_valueSize(param); 212 status = pFx->getParameter(p); 213 if (android::NO_ERROR == status) { 214 status = p->status; 215 if (android::NO_ERROR == status) { 216 memcpy(pValue, p->data + p->psize, p->vsize); 217 } 218 } 219 220 return status; 221 } 222 223 224//----------------------------------------------------------------------------- 225android::status_t android_eq_setParam(const android::sp<android::AudioEffect>& pFx, 226 int32_t param, int32_t param2, void *pValue) 227{ 228 android::status_t status; 229 uint32_t buf32[(EQUALIZER_PARAM_SIZE_MAX - 1) / sizeof(uint32_t) + 1]; 230 effect_param_t *p = (effect_param_t *)buf32; 231 232 p->psize = eq_paramSize(param); 233 *(int32_t *)p->data = param; 234 if (p->psize == 2 * sizeof(int32_t)) { 235 *((int32_t *)p->data + 1) = param2; 236 } 237 p->vsize = eq_valueSize(param); 238 memcpy(p->data + p->psize, pValue, p->vsize); 239 status = pFx->setParameter(p); 240 if (android::NO_ERROR == status) { 241 status = p->status; 242 } 243 244 return status; 245} 246 247//----------------------------------------------------------------------------- 248android::status_t android_bb_setParam(const android::sp<android::AudioEffect>& pFx, 249 int32_t param, void *pValue) { 250 251 return android_fx_setParam(pFx, param, BASSBOOST_PARAM_SIZE_MAX, 252 pValue, bb_valueSize(param)); 253} 254 255//----------------------------------------------------------------------------- 256android::status_t android_bb_getParam(const android::sp<android::AudioEffect>& pFx, 257 int32_t param, void *pValue) { 258 259 return android_fx_getParam(pFx, param, BASSBOOST_PARAM_SIZE_MAX, 260 pValue, bb_valueSize(param)); 261} 262 263//----------------------------------------------------------------------------- 264void android_bb_init(audio_session_t sessionId, IBassBoost* ibb) { 265 SL_LOGV("session %d", sessionId); 266 267 if (!android_fx_initEffectObj(sessionId, ibb->mBassBoostEffect, 268 &ibb->mBassBoostDescriptor.type)) 269 { 270 SL_LOGE("BassBoost effect initialization failed"); 271 return; 272 } 273 274 // initialize strength 275 int16_t strength; 276 if (android::NO_ERROR == android_bb_getParam(ibb->mBassBoostEffect, 277 BASSBOOST_PARAM_STRENGTH, &strength)) { 278 ibb->mStrength = (SLpermille) strength; 279 } 280} 281 282 283//----------------------------------------------------------------------------- 284void android_eq_init(audio_session_t sessionId, IEqualizer* ieq) { 285 SL_LOGV("android_eq_init on session %d", sessionId); 286 287 if (!android_fx_initEffectObj(sessionId, ieq->mEqEffect, &ieq->mEqDescriptor.type)) { 288 SL_LOGE("Equalizer effect initialization failed"); 289 return; 290 } 291 292 // initialize number of bands, band level range, and number of presets 293 uint16_t num = 0; 294 if (android::NO_ERROR == android_eq_getParam(ieq->mEqEffect, EQ_PARAM_NUM_BANDS, 0, &num)) { 295 ieq->mNumBands = num; 296 } 297 int16_t range[2] = {0, 0}; 298 if (android::NO_ERROR == android_eq_getParam(ieq->mEqEffect, EQ_PARAM_LEVEL_RANGE, 0, range)) { 299 ieq->mBandLevelRangeMin = range[0]; 300 ieq->mBandLevelRangeMax = range[1]; 301 } 302 303 SL_LOGV(" EQ init: num bands = %u, band range=[%d %d]mB", num, range[0], range[1]); 304 305 // FIXME don't store presets names, they can be queried each time they're needed 306 // initialize preset number and names, store in IEngine 307 uint16_t numPresets = 0; 308 if (android::NO_ERROR == android_eq_getParam(ieq->mEqEffect, 309 EQ_PARAM_GET_NUM_OF_PRESETS, 0, &numPresets)) { 310 ieq->mThis->mEngine->mEqNumPresets = numPresets; 311 ieq->mNumPresets = numPresets; 312 } 313 314 object_lock_exclusive(&ieq->mThis->mEngine->mObject); 315 char name[EFFECT_STRING_LEN_MAX]; 316 if ((0 < numPresets) && (NULL == ieq->mThis->mEngine->mEqPresetNames)) { 317 ieq->mThis->mEngine->mEqPresetNames = (char **)new char *[numPresets]; 318 for(uint32_t i = 0 ; i < numPresets ; i++) { 319 if (android::NO_ERROR == android_eq_getParam(ieq->mEqEffect, 320 EQ_PARAM_GET_PRESET_NAME, i, name)) { 321 ieq->mThis->mEngine->mEqPresetNames[i] = new char[strlen(name) + 1]; 322 strcpy(ieq->mThis->mEngine->mEqPresetNames[i], name); 323 SL_LOGV(" EQ init: presets = %u is %s", i, ieq->mThis->mEngine->mEqPresetNames[i]); 324 } 325 } 326 } 327 object_unlock_exclusive(&ieq->mThis->mEngine->mObject); 328 329} 330 331 332//----------------------------------------------------------------------------- 333void android_virt_init(audio_session_t sessionId, IVirtualizer* ivi) { 334 SL_LOGV("android_virt_init on session %d", sessionId); 335 336 if (!android_fx_initEffectObj(sessionId, ivi->mVirtualizerEffect, 337 &ivi->mVirtualizerDescriptor.type)) { 338 SL_LOGE("Virtualizer effect initialization failed"); 339 return; 340 } 341 342 // initialize strength 343 int16_t strength; 344 if (android::NO_ERROR == android_virt_getParam(ivi->mVirtualizerEffect, 345 VIRTUALIZER_PARAM_STRENGTH, &strength)) { 346 ivi->mStrength = (SLpermille) strength; 347 } 348} 349 350//----------------------------------------------------------------------------- 351android::status_t android_virt_setParam(const android::sp<android::AudioEffect>& pFx, 352 int32_t param, void *pValue) { 353 354 return android_fx_setParam(pFx, param, VIRTUALIZER_PARAM_SIZE_MAX, 355 pValue, virt_valueSize(param)); 356} 357 358//----------------------------------------------------------------------------- 359android::status_t android_virt_getParam(const android::sp<android::AudioEffect>& pFx, 360 int32_t param, void *pValue) { 361 362 return android_fx_getParam(pFx, param, VIRTUALIZER_PARAM_SIZE_MAX, 363 pValue, virt_valueSize(param)); 364} 365 366 367//----------------------------------------------------------------------------- 368void android_prev_init(IPresetReverb* ipr) { 369 SL_LOGV("session is implicitly %d (aux effect)", AUDIO_SESSION_OUTPUT_MIX); 370 371 if (!android_fx_initEffectObj(AUDIO_SESSION_OUTPUT_MIX /*sessionId*/, 372 ipr->mPresetReverbEffect, &ipr->mPresetReverbDescriptor.type)) { 373 SL_LOGE("PresetReverb effect initialization failed"); 374 return; 375 } 376 377 // initialize preset 378 uint16_t preset; 379 if (android::NO_ERROR == android_prev_getPreset(ipr->mPresetReverbEffect, &preset)) { 380 ipr->mPreset = preset; 381 // enable the effect if it has a preset loaded 382 ipr->mPresetReverbEffect->setEnabled(SL_REVERBPRESET_NONE != preset); 383 } 384} 385 386//----------------------------------------------------------------------------- 387android::status_t android_prev_setPreset(const android::sp<android::AudioEffect>& pFx, 388 uint16_t preset) { 389 android::status_t status = android_fx_setParam(pFx, REVERB_PARAM_PRESET, 390 PRESETREVERB_PARAM_SIZE_MAX, &preset, sizeof(uint16_t)); 391 // enable the effect if the preset is different from SL_REVERBPRESET_NONE 392 pFx->setEnabled(SL_REVERBPRESET_NONE != preset); 393 return status; 394} 395 396//----------------------------------------------------------------------------- 397android::status_t android_prev_getPreset(const android::sp<android::AudioEffect>& pFx, 398 uint16_t* preset) { 399 return android_fx_getParam(pFx, REVERB_PARAM_PRESET, PRESETREVERB_PARAM_SIZE_MAX, preset, 400 sizeof(uint16_t)); 401} 402 403 404//----------------------------------------------------------------------------- 405void android_erev_init(IEnvironmentalReverb* ier) { 406 SL_LOGV("session is implicitly %d (aux effect)", AUDIO_SESSION_OUTPUT_MIX); 407 408 if (!android_fx_initEffectObj(AUDIO_SESSION_OUTPUT_MIX /*sessionId*/, 409 ier->mEnvironmentalReverbEffect, &ier->mEnvironmentalReverbDescriptor.type)) { 410 SL_LOGE("EnvironmentalReverb effect initialization failed"); 411 return; 412 } 413 414 // enable env reverb: other SL ES effects have an explicit SetEnabled() function, and the 415 // preset reverb state depends on the selected preset. 416 ier->mEnvironmentalReverbEffect->setEnabled(true); 417 418 // initialize reverb properties 419 SLEnvironmentalReverbSettings properties; 420 if (android::NO_ERROR == android_erev_getParam(ier->mEnvironmentalReverbEffect, 421 REVERB_PARAM_PROPERTIES, &properties)) { 422 ier->mProperties = properties; 423 } 424} 425 426//----------------------------------------------------------------------------- 427android::status_t android_erev_setParam(const android::sp<android::AudioEffect>& pFx, 428 int32_t param, void *pValue) { 429 430 // given the size difference between a single reverb property and the whole set of reverb 431 // properties, select which max size to pass to avoid allocating too much memory 432 if (param == REVERB_PARAM_PROPERTIES) { 433 return android_fx_setParam(pFx, param, ENVREVERB_PARAM_SIZE_MAX_ALL, 434 pValue, erev_valueSize(param)); 435 } else { 436 return android_fx_setParam(pFx, param, ENVREVERB_PARAM_SIZE_MAX_SINGLE, 437 pValue, erev_valueSize(param)); 438 } 439} 440 441//----------------------------------------------------------------------------- 442android::status_t android_erev_getParam(const android::sp<android::AudioEffect>& pFx, 443 int32_t param, void *pValue) { 444 445 // given the size difference between a single reverb property and the whole set of reverb 446 // properties, select which max size to pass to avoid allocating too much memory 447 if (param == REVERB_PARAM_PROPERTIES) { 448 return android_fx_getParam(pFx, param, ENVREVERB_PARAM_SIZE_MAX_ALL, 449 pValue, erev_valueSize(param)); 450 } else { 451 return android_fx_getParam(pFx, param, ENVREVERB_PARAM_SIZE_MAX_SINGLE, 452 pValue, erev_valueSize(param)); 453 } 454} 455 456//----------------------------------------------------------------------------- 457void android_aec_init(audio_session_t sessionId, IAndroidAcousticEchoCancellation* iaec) { 458 SL_LOGV("android_aec_init on session %d", sessionId); 459 460 if (!android_fx_initEffectObj(sessionId, iaec->mAECEffect, 461 &iaec->mAECDescriptor.type)) { 462 SL_LOGE("AEC effect initialization failed"); 463 return; 464 } 465} 466 467//----------------------------------------------------------------------------- 468void android_agc_init(audio_session_t sessionId, IAndroidAutomaticGainControl* iagc) { 469 SL_LOGV("android_agc_init on session %d", sessionId); 470 471 if (!android_fx_initEffectObj(sessionId, iagc->mAGCEffect, 472 &iagc->mAGCDescriptor.type)) { 473 SL_LOGE("AGC effect initialization failed"); 474 return; 475 } 476} 477 478//----------------------------------------------------------------------------- 479void android_ns_init(audio_session_t sessionId, IAndroidNoiseSuppression* ins) { 480 SL_LOGV("android_ns_init on session %d", sessionId); 481 482 if (!android_fx_initEffectObj(sessionId, ins->mNSEffect, 483 &ins->mNSDescriptor.type)) { 484 SL_LOGE("NS effect initialization failed"); 485 return; 486 } 487} 488 489//----------------------------------------------------------------------------- 490/** 491 * pre-condition: 492 * ap != NULL 493 * for media players: 494 * ap->mAPlayer != 0 495 * ap->mTrackPlayer->mAudioTrack == 0 496 * for buffer queue players: 497 * ap->mAPlayer == 0 498 * ap->mTrackPlayer->mAudioTrack != 0 is optional; if no track yet then the setting is deferred 499 */ 500android::status_t android_fxSend_attach(CAudioPlayer* ap, bool attach, 501 const android::sp<android::AudioEffect>& pFx, SLmillibel sendLevel) { 502 503 if (pFx == 0) { 504 return android::INVALID_OPERATION; 505 } 506 507 // There are 3 cases: 508 // mAPlayer != 0 && mAudioTrack == 0 means playing decoded audio 509 // mAPlayer == 0 && mAudioTrack != 0 means playing PCM audio 510 // mAPlayer == 0 && mAudioTrack == 0 means player not fully configured yet 511 // The asserts document and verify this. 512 if (ap->mAPlayer != 0) { 513 assert(ap->mTrackPlayer->mAudioTrack == 0); 514 if (attach) { 515 ap->mAPlayer->attachAuxEffect(pFx->id()); 516 ap->mAPlayer->setAuxEffectSendLevel( sles_to_android_amplification(sendLevel) ); 517 } else { 518 ap->mAPlayer->attachAuxEffect(0); 519 } 520 return android::NO_ERROR; 521 } 522 523 if (ap->mTrackPlayer->mAudioTrack == 0) { 524 // the player doesn't have an AudioTrack at the moment, so store this info to use it 525 // when the AudioTrack becomes available 526 if (attach) { 527 ap->mAuxEffect = pFx; 528 } else { 529 ap->mAuxEffect.clear(); 530 } 531 // we keep track of the send level, independently of the current audio player level 532 ap->mAuxSendLevel = sendLevel - ap->mVolume.mLevel; 533 return android::NO_ERROR; 534 } 535 536 if (attach) { 537 android::status_t status = ap->mTrackPlayer->mAudioTrack->attachAuxEffect(pFx->id()); 538 //SL_LOGV("attachAuxEffect(%d) returned %d", pFx->id(), status); 539 if (android::NO_ERROR == status) { 540 status = 541 ap->mTrackPlayer->mAudioTrack->setAuxEffectSendLevel( 542 sles_to_android_amplification(sendLevel) ); 543 } 544 return status; 545 } else { 546 return ap->mTrackPlayer->mAudioTrack->attachAuxEffect(0); 547 } 548} 549 550//----------------------------------------------------------------------------- 551/** 552 * pre-condition: 553 * ap != NULL 554 * ap->mOutputMix != NULL 555 */ 556SLresult android_fxSend_attachToAux(CAudioPlayer* ap, SLInterfaceID pUuid, SLboolean attach, 557 SLmillibel sendLevel) { 558 COutputMix *outputMix = CAudioPlayer_GetOutputMix(ap); 559 ssize_t index = outputMix->mAndroidEffect.mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); 560 561 if (0 > index) { 562 SL_LOGE("invalid effect ID: no such effect attached to the OutputMix"); 563 return SL_RESULT_PARAMETER_INVALID; 564 } 565 566 android::sp<android::AudioEffect> pFx = 567 outputMix->mAndroidEffect.mEffects->valueAt(index); 568 if (pFx == 0) { 569 return SL_RESULT_RESOURCE_ERROR; 570 } 571 if (android::NO_ERROR == android_fxSend_attach( ap, (bool) attach, pFx, sendLevel) ) { 572 return SL_RESULT_SUCCESS; 573 } else { 574 return SL_RESULT_RESOURCE_ERROR; 575 } 576 577} 578 579//----------------------------------------------------------------------------- 580/** 581 * pre-condition: 582 * ap != NULL 583 * for media players: 584 * ap->mAPlayer != 0 585 * ap->mTrackPlayer->mAudioTrack == 0 586 * for buffer queue players: 587 * ap->mAPlayer == 0 588 * ap->mTrackPlayer->mAudioTrack != 0 is optional; if no track yet then the setting is deferred 589 */ 590android::status_t android_fxSend_setSendLevel(CAudioPlayer* ap, SLmillibel sendLevel) { 591 // we keep track of the send level, independently of the current audio player level 592 ap->mAuxSendLevel = sendLevel - ap->mVolume.mLevel; 593 594 if (ap->mAPlayer != 0) { 595 assert(ap->mTrackPlayer->mAudioTrack == 0); 596 ap->mAPlayer->setAuxEffectSendLevel( sles_to_android_amplification(sendLevel) ); 597 return android::NO_ERROR; 598 } 599 600 if (ap->mTrackPlayer->mAudioTrack == 0) { 601 return android::NO_ERROR; 602 } 603 604 return ap->mTrackPlayer->mAudioTrack->setAuxEffectSendLevel( 605 sles_to_android_amplification(sendLevel) ); 606} 607 608//----------------------------------------------------------------------------- 609android::status_t android_fx_setParam(const android::sp<android::AudioEffect>& pFx, 610 int32_t param, uint32_t paramSizeMax, void *pValue, uint32_t valueSize) 611{ 612 613 android::status_t status; 614 uint32_t buf32[(paramSizeMax - 1) / sizeof(uint32_t) + 1]; 615 effect_param_t *p = (effect_param_t *)buf32; 616 617 p->psize = sizeof(int32_t); 618 *(int32_t *)p->data = param; 619 p->vsize = valueSize; 620 memcpy(p->data + p->psize, pValue, p->vsize); 621 status = pFx->setParameter(p); 622 if (android::NO_ERROR == status) { 623 status = p->status; 624 } 625 return status; 626} 627 628 629//----------------------------------------------------------------------------- 630android::status_t android_fx_getParam(const android::sp<android::AudioEffect>& pFx, 631 int32_t param, uint32_t paramSizeMax, void *pValue, uint32_t valueSize) 632{ 633 android::status_t status; 634 uint32_t buf32[(paramSizeMax - 1) / sizeof(uint32_t) + 1]; 635 effect_param_t *p = (effect_param_t *)buf32; 636 637 p->psize = sizeof(int32_t); 638 *(int32_t *)p->data = param; 639 p->vsize = valueSize; 640 status = pFx->getParameter(p); 641 if (android::NO_ERROR == status) { 642 status = p->status; 643 if (android::NO_ERROR == status) { 644 memcpy(pValue, p->data + p->psize, p->vsize); 645 } 646 } 647 648 return status; 649} 650 651 652//----------------------------------------------------------------------------- 653SLresult android_fx_statusToResult(android::status_t status) { 654 655 if ((android::INVALID_OPERATION == status) || (android::DEAD_OBJECT == status)) { 656 return SL_RESULT_CONTROL_LOST; 657 } else { 658 return SL_RESULT_SUCCESS; 659 } 660} 661 662 663//----------------------------------------------------------------------------- 664bool android_fx_initEffectObj(audio_session_t sessionId, android::sp<android::AudioEffect>& effect, 665 const effect_uuid_t *type) { 666 //SL_LOGV("android_fx_initEffectObj on session %d", sessionId); 667 668 effect = new android::AudioEffect(type, android::String16(), EFFECT_UUID_NULL, 669 0,// priority 670 0,// effect callback 671 0,// callback data 672 sessionId,// session ID 673 0 );// output 674 675 android::status_t status = effect->initCheck(); 676 if (android::NO_ERROR != status) { 677 effect.clear(); 678 SL_LOGE("Effect initCheck() returned %d", status); 679 return false; 680 } 681 682 return true; 683} 684 685 686//----------------------------------------------------------------------------- 687bool android_fx_initEffectDescriptor(const SLInterfaceID effectId, 688 effect_descriptor_t* fxDescrLoc) { 689 uint32_t numEffects = 0; 690 effect_descriptor_t descriptor; 691 bool foundEffect = false; 692 693 // any effects? 694 android::status_t res = android::AudioEffect::queryNumberEffects(&numEffects); 695 if (android::NO_ERROR != res) { 696 SL_LOGE("unable to find any effects."); 697 goto effectError; 698 } 699 700 // request effect in the effects? 701 for (uint32_t i=0 ; i < numEffects ; i++) { 702 res = android::AudioEffect::queryEffect(i, &descriptor); 703 if ((android::NO_ERROR == res) && 704 (0 == memcmp(effectId, &descriptor.type, sizeof(effect_uuid_t)))) { 705 SL_LOGV("found effect %d %s", i, descriptor.name); 706 foundEffect = true; 707 break; 708 } 709 } 710 if (foundEffect) { 711 memcpy(fxDescrLoc, &descriptor, sizeof(effect_descriptor_t)); 712 } else { 713 SL_LOGE("unable to find an implementation for the requested effect."); 714 goto effectError; 715 } 716 717 return true; 718 719effectError: 720 // the requested effect wasn't found 721 memset(fxDescrLoc, 0, sizeof(effect_descriptor_t)); 722 723 return false; 724} 725 726//----------------------------------------------------------------------------- 727SLresult android_genericFx_queryNumEffects(SLuint32 *pNumSupportedAudioEffects) { 728 729 if (NULL == pNumSupportedAudioEffects) { 730 return SL_RESULT_PARAMETER_INVALID; 731 } 732 733 android::status_t status = 734 android::AudioEffect::queryNumberEffects((uint32_t*)pNumSupportedAudioEffects); 735 736 SLresult result = SL_RESULT_SUCCESS; 737 switch (status) { 738 case android::NO_ERROR: 739 result = SL_RESULT_SUCCESS; 740 break; 741 case android::PERMISSION_DENIED: 742 result = SL_RESULT_PERMISSION_DENIED; 743 break; 744 case android::NO_INIT: 745 result = SL_RESULT_RESOURCE_ERROR; 746 break; 747 case android::BAD_VALUE: 748 result = SL_RESULT_PARAMETER_INVALID; 749 break; 750 default: 751 result = SL_RESULT_INTERNAL_ERROR; 752 SL_LOGE("received invalid status %d from AudioEffect::queryNumberEffects()", status); 753 break; 754 } 755 return result; 756} 757 758 759//----------------------------------------------------------------------------- 760SLresult android_genericFx_queryEffect(SLuint32 index, effect_descriptor_t* pDescriptor) { 761 762 if (NULL == pDescriptor) { 763 return SL_RESULT_PARAMETER_INVALID; 764 } 765 766 android::status_t status = 767 android::AudioEffect::queryEffect(index, pDescriptor); 768 769 SLresult result = SL_RESULT_SUCCESS; 770 if (android::NO_ERROR != status) { 771 switch (status) { 772 case android::PERMISSION_DENIED: 773 result = SL_RESULT_PERMISSION_DENIED; 774 break; 775 case android::NO_INIT: 776 case android::INVALID_OPERATION: 777 result = SL_RESULT_RESOURCE_ERROR; 778 break; 779 case android::BAD_VALUE: 780 result = SL_RESULT_PARAMETER_INVALID; 781 break; 782 default: 783 result = SL_RESULT_INTERNAL_ERROR; 784 SL_LOGE("received invalid status %d from AudioEffect::queryNumberEffects()", status); 785 break; 786 } 787 // an error occurred, reset the effect descriptor 788 memset(pDescriptor, 0, sizeof(effect_descriptor_t)); 789 } 790 791 return result; 792} 793 794 795//----------------------------------------------------------------------------- 796SLresult android_genericFx_createEffect(IAndroidEffect* iae, SLInterfaceID pUuid, 797 audio_session_t sessionId) 798{ 799 800 SLresult result = SL_RESULT_SUCCESS; 801 802 // does this effect already exist? 803 if (0 <= iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid))) { 804 return result; 805 } 806 807 // create new effect 808 android::sp<android::AudioEffect> pFx = new android::AudioEffect( 809 NULL, // not using type to create effect 810 android::String16(), 811 (const effect_uuid_t*)pUuid, 812 0,// priority 813 0,// effect callback 814 0,// callback data 815 sessionId, 816 0 );// output 817 818 // verify effect was successfully created before storing it 819 android::status_t status = pFx->initCheck(); 820 if (android::NO_ERROR != status) { 821 SL_LOGE("AudioEffect initCheck() returned %d, effect will not be stored", status); 822 result = SL_RESULT_RESOURCE_ERROR; 823 } else { 824 SL_LOGV("AudioEffect successfully created on session %d", sessionId); 825 iae->mEffects->add(KEY_FROM_GUID(pUuid), pFx); 826 } 827 828 return result; 829} 830 831 832//----------------------------------------------------------------------------- 833SLresult android_genericFx_releaseEffect(IAndroidEffect* iae, SLInterfaceID pUuid) { 834 835 ssize_t index = iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); 836 837 if (0 > index) { 838 return SL_RESULT_PARAMETER_INVALID; 839 } else { 840 iae->mEffects->removeItem(index); 841 return SL_RESULT_SUCCESS; 842 } 843} 844 845 846//----------------------------------------------------------------------------- 847SLresult android_genericFx_setEnabled(IAndroidEffect* iae, SLInterfaceID pUuid, SLboolean enabled) { 848 849 ssize_t index = iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); 850 851 if (0 > index) { 852 return SL_RESULT_PARAMETER_INVALID; 853 } else { 854 android::sp<android::AudioEffect> pFx = iae->mEffects->valueAt(index); 855 android::status_t status = pFx->setEnabled(SL_BOOLEAN_TRUE == enabled); 856 return android_fx_statusToResult(status); 857 } 858} 859 860 861//----------------------------------------------------------------------------- 862SLresult android_genericFx_isEnabled(IAndroidEffect* iae, SLInterfaceID pUuid, SLboolean *pEnabled) 863{ 864 ssize_t index = iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); 865 866 if (0 > index) { 867 return SL_RESULT_PARAMETER_INVALID; 868 } else { 869 android::sp<android::AudioEffect> pFx = iae->mEffects->valueAt(index); 870 *pEnabled = (SLboolean) pFx->getEnabled(); 871 return SL_RESULT_SUCCESS; 872 } 873} 874 875 876//----------------------------------------------------------------------------- 877SLresult android_genericFx_sendCommand(IAndroidEffect* iae, SLInterfaceID pUuid, 878 SLuint32 command, SLuint32 commandSize, void* pCommandData, 879 SLuint32 *replySize, void *pReplyData) { 880 881 ssize_t index = iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); 882 883 if (0 > index) { 884 return SL_RESULT_PARAMETER_INVALID; 885 } else { 886 android::sp<android::AudioEffect> pFx = iae->mEffects->valueAt(index); 887 android::status_t status = pFx->command( 888 (uint32_t) command, 889 (uint32_t) commandSize, 890 pCommandData, 891 (uint32_t*)replySize, 892 pReplyData); 893 if (android::BAD_VALUE == status) { 894 return SL_RESULT_PARAMETER_INVALID; 895 } else { 896 return SL_RESULT_SUCCESS; 897 } 898 } 899} 900 901//----------------------------------------------------------------------------- 902/** 903 * returns true if the given effect id is present in the AndroidEffect interface 904 */ 905bool android_genericFx_hasEffect(IAndroidEffect* iae, SLInterfaceID pUuid) { 906 return( 0 <= iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid))); 907} 908 909//----------------------------------------------------------------------------- 910static const int AEC_PARAM_SIZE_MAX = sizeof(effect_param_t) + (2 * sizeof(int32_t)); 911/** 912 * returns the size in bytes of the value of each acoustic echo cancellation parameter 913 */ 914uint32_t aec_valueSize(int32_t param) { 915 uint32_t size; 916 switch (param) { 917 case AEC_PARAM_ECHO_DELAY: 918 size = sizeof(int32_t); 919 break; 920 default: 921 size = sizeof(int32_t); 922 SL_LOGE("Trying to access an unknown Acoustic Echo Cancellation parameter %d", param); 923 break; 924 } 925 926 return size; 927} 928 929android::status_t android_aec_setParam(const android::sp<android::AudioEffect>& pFx, 930 int32_t param, void *pValue) { 931 return android_fx_setParam(pFx, param, AEC_PARAM_SIZE_MAX, 932 pValue, aec_valueSize(param)); 933} 934 935android::status_t android_aec_getParam(const android::sp<android::AudioEffect>& pFx, 936 int32_t param, void *pValue) { 937 return android_fx_getParam(pFx, param, AEC_PARAM_SIZE_MAX, 938 pValue, aec_valueSize(param)); 939} 940 941//----------------------------------------------------------------------------- 942static const int AGC_PARAM_SIZE_MAX = sizeof(effect_param_t) + (2 * sizeof(int16_t)) + sizeof(bool); 943/** 944 * returns the size in bytes of the value of each automatic gain control parameter 945 */ 946uint32_t agc_valueSize(int32_t param) { 947 uint32_t size; 948 switch (param) { 949 case AGC_PARAM_TARGET_LEVEL: 950 case AGC_PARAM_COMP_GAIN: 951 size = sizeof(int16_t); 952 break; 953 case AGC_PARAM_LIMITER_ENA: 954 size = sizeof(bool); 955 break; 956 default: 957 size = sizeof(int32_t); 958 SL_LOGE("Trying to access an unknown Automatic Gain Control parameter %d", param); 959 break; 960 } 961 962 return size; 963} 964 965android::status_t android_agc_setParam(const android::sp<android::AudioEffect>& pFx, 966 int32_t param, void *pValue) { 967 return android_fx_setParam(pFx, param, AGC_PARAM_SIZE_MAX, 968 pValue, agc_valueSize(param)); 969} 970 971android::status_t android_agc_getParam(const android::sp<android::AudioEffect>& pFx, 972 int32_t param, void *pValue) { 973 return android_fx_getParam(pFx, param, AGC_PARAM_SIZE_MAX, 974 pValue, agc_valueSize(param)); 975} 976 977//----------------------------------------------------------------------------- 978static const int NS_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t); 979/** 980 * returns the size in bytes of the value of each noise suppression parameter 981 */ 982uint32_t ns_valueSize(int32_t param) { 983 uint32_t size; 984 switch (param) { 985 case NS_PARAM_LEVEL: 986 size = sizeof(int32_t); 987 break; 988 default: 989 size = sizeof(int32_t); 990 SL_LOGE("Trying to access an unknown Noise suppression parameter %d", param); 991 break; 992 } 993 994 return size; 995} 996 997android::status_t android_ns_setParam(const android::sp<android::AudioEffect>& pFx, 998 int32_t param, void *pValue) 999{ 1000 return android_fx_setParam(pFx, param, NS_PARAM_SIZE_MAX, 1001 pValue, ns_valueSize(param)); 1002} 1003 1004android::status_t android_ns_getParam(const android::sp<android::AudioEffect>& pFx, 1005 int32_t param, void *pValue) 1006{ 1007 return android_fx_getParam(pFx, param, NS_PARAM_SIZE_MAX, 1008 pValue, ns_valueSize(param)); 1009} 1010