Home | History | Annotate | Download | only in itf 
      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 /* Equalizer implementation */
     18 
     19 #include "sles_allinclusive.h"
     20 #ifdef ANDROID
     21 #include <audio_effects/effect_equalizer.h>
     22 #endif
     23 
     24 #define MAX_EQ_PRESETS 3
     25 
     26 #if !defined(ANDROID)
     27 static const struct EqualizerBand EqualizerBands[MAX_EQ_BANDS] = {
     28     {1000, 1500, 2000},
     29     {2000, 3000, 4000},
     30     {4000, 5500, 7000},
     31     {7000, 8000, 9000}
     32 };
     33 
     34 static const struct EqualizerPreset {
     35     const char *mName;
     36     SLmillibel mLevels[MAX_EQ_BANDS];
     37 } EqualizerPresets[MAX_EQ_PRESETS] = {
     38     {"Default", {0, 0, 0, 0}},
     39     {"Bass", {500, 200, 100, 0}},
     40     {"Treble", {0, 100, 200, 500}}
     41 };
     42 #endif
     43 
     44 
     45 #if defined(ANDROID)
     46 /**
     47  * returns true if this interface is not associated with an initialized Equalizer effect
     48  */
     49 static inline bool NO_EQ(IEqualizer* v) {
     50     return (v->mEqEffect == 0);
     51 }
     52 #endif
     53 
     54 
     55 static SLresult IEqualizer_SetEnabled(SLEqualizerItf self, SLboolean enabled)
     56 {
     57     SL_ENTER_INTERFACE
     58 
     59     IEqualizer *thiz = (IEqualizer *) self;
     60     interface_lock_exclusive(thiz);
     61     thiz->mEnabled = (SLboolean) enabled;
     62 #if !defined(ANDROID)
     63     result = SL_RESULT_SUCCESS;
     64 #else
     65     if (NO_EQ(thiz)) {
     66         result = SL_RESULT_CONTROL_LOST;
     67     } else {
     68         android::status_t status =
     69                 thiz->mEqEffect->setEnabled((bool) thiz->mEnabled);
     70         result = android_fx_statusToResult(status);
     71     }
     72 #endif
     73     interface_unlock_exclusive(thiz);
     74 
     75     SL_LEAVE_INTERFACE
     76 }
     77 
     78 
     79 static SLresult IEqualizer_IsEnabled(SLEqualizerItf self, SLboolean *pEnabled)
     80 {
     81     SL_ENTER_INTERFACE
     82 
     83     if (NULL == pEnabled) {
     84         result = SL_RESULT_PARAMETER_INVALID;
     85     } else {
     86         IEqualizer *thiz = (IEqualizer *) self;
     87         interface_lock_exclusive(thiz);
     88         SLboolean enabled = thiz->mEnabled;
     89  #if !defined(ANDROID)
     90         *pEnabled = enabled;
     91         result = SL_RESULT_SUCCESS;
     92  #else
     93         if (NO_EQ(thiz)) {
     94             result = SL_RESULT_CONTROL_LOST;
     95         } else {
     96             *pEnabled = (SLboolean) thiz->mEqEffect->getEnabled();
     97             result = SL_RESULT_SUCCESS;
     98         }
     99  #endif
    100         interface_unlock_exclusive(thiz);
    101     }
    102 
    103       SL_LEAVE_INTERFACE
    104 }
    105 
    106 
    107 static SLresult IEqualizer_GetNumberOfBands(SLEqualizerItf self, SLuint16 *pNumBands)
    108 {
    109     SL_ENTER_INTERFACE
    110 
    111     if (NULL == pNumBands) {
    112         result = SL_RESULT_PARAMETER_INVALID;
    113     } else {
    114         IEqualizer *thiz = (IEqualizer *) self;
    115         // Note: no lock, but OK because it is const
    116         *pNumBands = thiz->mNumBands;
    117         result = SL_RESULT_SUCCESS;
    118     }
    119 
    120     SL_LEAVE_INTERFACE
    121 }
    122 
    123 
    124 static SLresult IEqualizer_GetBandLevelRange(SLEqualizerItf self, SLmillibel *pMin,
    125     SLmillibel *pMax)
    126 {
    127     SL_ENTER_INTERFACE
    128 
    129     if (NULL == pMin && NULL == pMax) {
    130         result = SL_RESULT_PARAMETER_INVALID;
    131     } else {
    132         IEqualizer *thiz = (IEqualizer *) self;
    133         // Note: no lock, but OK because it is const
    134         if (NULL != pMin)
    135             *pMin = thiz->mBandLevelRangeMin;
    136         if (NULL != pMax)
    137             *pMax = thiz->mBandLevelRangeMax;
    138         result = SL_RESULT_SUCCESS;
    139     }
    140 
    141     SL_LEAVE_INTERFACE
    142 }
    143 
    144 
    145 static SLresult IEqualizer_SetBandLevel(SLEqualizerItf self, SLuint16 band, SLmillibel level)
    146 {
    147     SL_ENTER_INTERFACE
    148 
    149     IEqualizer *thiz = (IEqualizer *) self;
    150     if (!(thiz->mBandLevelRangeMin <= level && level <= thiz->mBandLevelRangeMax) ||
    151             (band >= thiz->mNumBands)) {
    152         result = SL_RESULT_PARAMETER_INVALID;
    153     } else {
    154         interface_lock_exclusive(thiz);
    155 #if !defined(ANDROID)
    156         thiz->mLevels[band] = level;
    157         thiz->mPreset = SL_EQUALIZER_UNDEFINED;
    158         result = SL_RESULT_SUCCESS;
    159 #else
    160         if (NO_EQ(thiz)) {
    161             result = SL_RESULT_CONTROL_LOST;
    162         } else {
    163             android::status_t status =
    164                 android_eq_setParam(thiz->mEqEffect, EQ_PARAM_BAND_LEVEL, band, &level);
    165             result = android_fx_statusToResult(status);
    166         }
    167 #endif
    168         interface_unlock_exclusive(thiz);
    169     }
    170 
    171     SL_LEAVE_INTERFACE
    172 }
    173 
    174 
    175 static SLresult IEqualizer_GetBandLevel(SLEqualizerItf self, SLuint16 band, SLmillibel *pLevel)
    176 {
    177     SL_ENTER_INTERFACE
    178 
    179     if (NULL == pLevel) {
    180         result = SL_RESULT_PARAMETER_INVALID;
    181     } else {
    182         IEqualizer *thiz = (IEqualizer *) self;
    183         // const, no lock needed
    184         if (band >= thiz->mNumBands) {
    185             result = SL_RESULT_PARAMETER_INVALID;
    186         } else {
    187             SLmillibel level = 0;
    188             interface_lock_shared(thiz);
    189 #if !defined(ANDROID)
    190             level = thiz->mLevels[band];
    191             result = SL_RESULT_SUCCESS;
    192 #else
    193             if (NO_EQ(thiz)) {
    194                 result = SL_RESULT_CONTROL_LOST;
    195             } else {
    196                 android::status_t status =
    197                     android_eq_getParam(thiz->mEqEffect, EQ_PARAM_BAND_LEVEL, band, &level);
    198                 result = android_fx_statusToResult(status);
    199             }
    200 #endif
    201             interface_unlock_shared(thiz);
    202             *pLevel = level;
    203         }
    204     }
    205 
    206     SL_LEAVE_INTERFACE
    207 }
    208 
    209 
    210 static SLresult IEqualizer_GetCenterFreq(SLEqualizerItf self, SLuint16 band, SLmilliHertz *pCenter)
    211 {
    212     SL_ENTER_INTERFACE
    213 
    214     if (NULL == pCenter) {
    215         result = SL_RESULT_PARAMETER_INVALID;
    216     } else {
    217         IEqualizer *thiz = (IEqualizer *) self;
    218         if (band >= thiz->mNumBands) {
    219             result = SL_RESULT_PARAMETER_INVALID;
    220         } else {
    221 #if !defined(ANDROID)
    222             // Note: no lock, but OK because it is const
    223             *pCenter = thiz->mBands[band].mCenter;
    224             result = SL_RESULT_SUCCESS;
    225 #else
    226             SLmilliHertz center = 0;
    227             interface_lock_shared(thiz);
    228             if (NO_EQ(thiz)) {
    229                 result = SL_RESULT_CONTROL_LOST;
    230             } else {
    231                 android::status_t status =
    232                     android_eq_getParam(thiz->mEqEffect, EQ_PARAM_CENTER_FREQ, band, &center);
    233                 result = android_fx_statusToResult(status);
    234             }
    235             interface_unlock_shared(thiz);
    236             *pCenter = center;
    237 #endif
    238         }
    239     }
    240 
    241     SL_LEAVE_INTERFACE
    242 }
    243 
    244 
    245 static SLresult IEqualizer_GetBandFreqRange(SLEqualizerItf self, SLuint16 band,
    246     SLmilliHertz *pMin, SLmilliHertz *pMax)
    247 {
    248     SL_ENTER_INTERFACE
    249 
    250     if (NULL == pMin && NULL == pMax) {
    251         result = SL_RESULT_PARAMETER_INVALID;
    252     } else {
    253         IEqualizer *thiz = (IEqualizer *) self;
    254         if (band >= thiz->mNumBands) {
    255             result = SL_RESULT_PARAMETER_INVALID;
    256         } else {
    257 #if !defined(ANDROID)
    258             // Note: no lock, but OK because it is const
    259             if (NULL != pMin)
    260                 *pMin = thiz->mBands[band].mMin;
    261             if (NULL != pMax)
    262                 *pMax = thiz->mBands[band].mMax;
    263             result = SL_RESULT_SUCCESS;
    264 #else
    265             SLmilliHertz range[2] = {0, 0}; // SLmilliHertz is SLuint32
    266             interface_lock_shared(thiz);
    267             if (NO_EQ(thiz)) {
    268                 result = SL_RESULT_CONTROL_LOST;
    269             } else {
    270                 android::status_t status =
    271                     android_eq_getParam(thiz->mEqEffect, EQ_PARAM_BAND_FREQ_RANGE, band, range);
    272                 result = android_fx_statusToResult(status);
    273             }
    274             interface_unlock_shared(thiz);
    275             if (NULL != pMin) {
    276                 *pMin = range[0];
    277             }
    278             if (NULL != pMax) {
    279                 *pMax = range[1];
    280             }
    281 #endif
    282         }
    283     }
    284 
    285     SL_LEAVE_INTERFACE
    286 }
    287 
    288 
    289 static SLresult IEqualizer_GetBand(SLEqualizerItf self, SLmilliHertz frequency, SLuint16 *pBand)
    290 {
    291     SL_ENTER_INTERFACE
    292 
    293     if (NULL == pBand) {
    294         result = SL_RESULT_PARAMETER_INVALID;
    295     } else {
    296         IEqualizer *thiz = (IEqualizer *) self;
    297 #if !defined(ANDROID)
    298         // search for band whose center frequency has the closest ratio to 1.0
    299         // assumes bands are unsorted (a pessimistic assumption)
    300         // assumes bands can overlap (a pessimistic assumption)
    301         // assumes a small number of bands, so no need for a fancier algorithm
    302         const struct EqualizerBand *band;
    303         float floatFreq = (float) frequency;
    304         float bestRatio = 0.0;
    305         SLuint16 bestBand = SL_EQUALIZER_UNDEFINED;
    306         for (band = thiz->mBands; band < &thiz->mBands[thiz->mNumBands]; ++band) {
    307             if (!(band->mMin <= frequency && frequency <= band->mMax))
    308                 continue;
    309             assert(band->mMin <= band->mCenter && band->mCenter <= band->mMax);
    310             assert(band->mCenter != 0);
    311             float ratio = frequency <= band->mCenter ?
    312                 floatFreq / band->mCenter : band->mCenter / floatFreq;
    313             if (ratio > bestRatio) {
    314                 bestRatio = ratio;
    315                 bestBand = band - thiz->mBands;
    316             }
    317         }
    318         *pBand = bestBand;
    319         result = SL_RESULT_SUCCESS;
    320 #else
    321         uint16_t band = 0;
    322         interface_lock_shared(thiz);
    323         if (NO_EQ(thiz)) {
    324             result = SL_RESULT_CONTROL_LOST;
    325         } else {
    326             android::status_t status =
    327                 android_eq_getParam(thiz->mEqEffect, EQ_PARAM_GET_BAND, frequency, &band);
    328             result = android_fx_statusToResult(status);
    329         }
    330         interface_unlock_shared(thiz);
    331         *pBand = (SLuint16)band;
    332 #endif
    333     }
    334 
    335     SL_LEAVE_INTERFACE
    336 }
    337 
    338 
    339 static SLresult IEqualizer_GetCurrentPreset(SLEqualizerItf self, SLuint16 *pPreset)
    340 {
    341     SL_ENTER_INTERFACE
    342 
    343     if (NULL == pPreset) {
    344         result = SL_RESULT_PARAMETER_INVALID;
    345     } else {
    346         IEqualizer *thiz = (IEqualizer *) self;
    347         interface_lock_shared(thiz);
    348 #if !defined(ANDROID)
    349         SLuint16 preset = thiz->mPreset;
    350         interface_unlock_shared(thiz);
    351         *pPreset = preset;
    352         result = SL_RESULT_SUCCESS;
    353 #else
    354         uint16_t preset = 0;
    355         if (NO_EQ(thiz)) {
    356             result = SL_RESULT_CONTROL_LOST;
    357         } else {
    358             android::status_t status =
    359                     android_eq_getParam(thiz->mEqEffect, EQ_PARAM_CUR_PRESET, 0, &preset);
    360             result = android_fx_statusToResult(status);
    361         }
    362         interface_unlock_shared(thiz);
    363 
    364         if (preset < 0) {
    365             *pPreset = SL_EQUALIZER_UNDEFINED;
    366         } else {
    367             *pPreset = (SLuint16) preset;
    368         }
    369 #endif
    370 
    371     }
    372 
    373     SL_LEAVE_INTERFACE
    374 }
    375 
    376 
    377 static SLresult IEqualizer_UsePreset(SLEqualizerItf self, SLuint16 index)
    378 {
    379     SL_ENTER_INTERFACE
    380     SL_LOGV("Equalizer::UsePreset index=%u", index);
    381 
    382     IEqualizer *thiz = (IEqualizer *) self;
    383     if (index >= thiz->mNumPresets) {
    384         result = SL_RESULT_PARAMETER_INVALID;
    385     } else {
    386         interface_lock_exclusive(thiz);
    387 #if !defined(ANDROID)
    388         SLuint16 band;
    389         for (band = 0; band < thiz->mNumBands; ++band)
    390             thiz->mLevels[band] = EqualizerPresets[index].mLevels[band];
    391         thiz->mPreset = index;
    392         interface_unlock_exclusive(thiz);
    393         result = SL_RESULT_SUCCESS;
    394 #else
    395         if (NO_EQ(thiz)) {
    396             result = SL_RESULT_CONTROL_LOST;
    397         } else {
    398             android::status_t status =
    399                 android_eq_setParam(thiz->mEqEffect, EQ_PARAM_CUR_PRESET, 0, &index);
    400             result = android_fx_statusToResult(status);
    401         }
    402         interface_unlock_shared(thiz);
    403 #endif
    404     }
    405 
    406     SL_LEAVE_INTERFACE
    407 }
    408 
    409 
    410 static SLresult IEqualizer_GetNumberOfPresets(SLEqualizerItf self, SLuint16 *pNumPresets)
    411 {
    412     SL_ENTER_INTERFACE
    413 
    414     if (NULL == pNumPresets) {
    415         result = SL_RESULT_PARAMETER_INVALID;
    416     } else {
    417         IEqualizer *thiz = (IEqualizer *) self;
    418         // Note: no lock, but OK because it is const
    419         *pNumPresets = thiz->mNumPresets;
    420 
    421         result = SL_RESULT_SUCCESS;
    422     }
    423 
    424     SL_LEAVE_INTERFACE
    425 }
    426 
    427 
    428 static SLresult IEqualizer_GetPresetName(SLEqualizerItf self, SLuint16 index, const SLchar **ppName)
    429 {
    430     SL_ENTER_INTERFACE
    431 
    432     if (NULL == ppName) {
    433         result = SL_RESULT_PARAMETER_INVALID;
    434     } else {
    435         IEqualizer *thiz = (IEqualizer *) self;
    436 #if !defined(ANDROID)
    437         if (index >= thiz->mNumPresets) {
    438             result = SL_RESULT_PARAMETER_INVALID;
    439         } else {
    440             *ppName = (SLchar *) thiz->mPresets[index].mName;
    441             result = SL_RESULT_SUCCESS;
    442         }
    443 #else
    444         if (index >= thiz->mNumPresets) {
    445             result = SL_RESULT_PARAMETER_INVALID;
    446         } else {
    447             // FIXME query preset name rather than retrieve it from the engine.
    448             //       In SL ES 1.0.1, the strings must exist for the lifetime of the engine.
    449             //       Starting in 1.1, this will change and we don't need to hold onto the strings
    450             //       for so long as they will copied into application space.
    451             *ppName = (SLchar *) thiz->mThis->mEngine->mEqPresetNames[index];
    452             result = SL_RESULT_SUCCESS;
    453         }
    454 #endif
    455     }
    456 
    457     SL_LEAVE_INTERFACE
    458 }
    459 
    460 
    461 static const struct SLEqualizerItf_ IEqualizer_Itf = {
    462     IEqualizer_SetEnabled,
    463     IEqualizer_IsEnabled,
    464     IEqualizer_GetNumberOfBands,
    465     IEqualizer_GetBandLevelRange,
    466     IEqualizer_SetBandLevel,
    467     IEqualizer_GetBandLevel,
    468     IEqualizer_GetCenterFreq,
    469     IEqualizer_GetBandFreqRange,
    470     IEqualizer_GetBand,
    471     IEqualizer_GetCurrentPreset,
    472     IEqualizer_UsePreset,
    473     IEqualizer_GetNumberOfPresets,
    474     IEqualizer_GetPresetName
    475 };
    476 
    477 void IEqualizer_init(void *self)
    478 {
    479     IEqualizer *thiz = (IEqualizer *) self;
    480     thiz->mItf = &IEqualizer_Itf;
    481     thiz->mEnabled = SL_BOOLEAN_FALSE;
    482     thiz->mPreset = SL_EQUALIZER_UNDEFINED;
    483 #if 0 < MAX_EQ_BANDS
    484     unsigned band;
    485     for (band = 0; band < MAX_EQ_BANDS; ++band)
    486         thiz->mLevels[band] = 0;
    487 #endif
    488     // const fields
    489     thiz->mNumPresets = 0;
    490     thiz->mNumBands = 0;
    491 #if !defined(ANDROID)
    492     thiz->mBands = EqualizerBands;
    493     thiz->mPresets = EqualizerPresets;
    494 #endif
    495     thiz->mBandLevelRangeMin = 0;
    496     thiz->mBandLevelRangeMax = 0;
    497 #if defined(ANDROID)
    498     memset(&thiz->mEqDescriptor, 0, sizeof(effect_descriptor_t));
    499     // placement new (explicit constructor)
    500     (void) new (&thiz->mEqEffect) android::sp<android::AudioEffect>();
    501 #endif
    502 }
    503 
    504 void IEqualizer_deinit(void *self)
    505 {
    506 #if defined(ANDROID)
    507     IEqualizer *thiz = (IEqualizer *) self;
    508     // explicit destructor
    509     thiz->mEqEffect.~sp();
    510 #endif
    511 }
    512 
    513 bool IEqualizer_Expose(void *self)
    514 {
    515 #if defined(ANDROID)
    516     IEqualizer *thiz = (IEqualizer *) self;
    517     if (!android_fx_initEffectDescriptor(SL_IID_EQUALIZER, &thiz->mEqDescriptor)) {
    518         SL_LOGE("Equalizer initialization failed");
    519         thiz->mNumPresets = 0;
    520         thiz->mNumBands = 0;
    521         thiz->mBandLevelRangeMin = 0;
    522         thiz->mBandLevelRangeMax = 0;
    523         return false;
    524     }
    525 #endif
    526     return true;
    527 }
    528