Android Audio代码分析20 - queryEffects函数

今天开始看看AudioEffect相关的接口。
这个类，之前有看过。不过当时只是从类的定义出发，了解了一下基本的内容。
这次从测试代码使用的接口出发，逐步撕开AudioEffect的面纱。


*****************************************源码*************************************************

    //Test case 0.0: test queryEffects() and available effects
    @LargeTest
    public void test0_0QueryEffects() throws Exception {


        AudioEffect.Descriptor[] desc = AudioEffect.queryEffects();


        assertTrue("test0_0QueryEffects: number of effects < 4: "+desc.length, (desc.length >= 4));


        boolean hasEQ = false;
        boolean hasBassBoost = false;
        boolean hasVirtualizer = false;
        boolean hasEnvReverb = false;


        for (int i = 0; i < desc.length; i++) {
            if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_EQUALIZER)) {
                hasEQ = true;
            } if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_BASS_BOOST)) {
                hasBassBoost = true;
            } else if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_VIRTUALIZER)) {
                hasVirtualizer = true;
            }
            else if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_ENV_REVERB)) {
                hasEnvReverb = true;
            }
        }
        assertTrue("test0_0QueryEffects: equalizer not found", hasEQ);
        assertTrue("test0_0QueryEffects: bass boost not found", hasBassBoost);
        assertTrue("test0_0QueryEffects: virtualizer not found", hasVirtualizer);
        assertTrue("test0_0QueryEffects: environmental reverb not found", hasEnvReverb);
    }

**********************************************************************************************
源码路径：
frameworks\base\media\tests\mediaframeworktest\src\com\android\mediaframeworktest\functional\MediaAudioEffectTest.java


#######################说明################################

    //Test case 0.0: test queryEffects() and available effects
    @LargeTest
    public void test0_0QueryEffects() throws Exception {


        AudioEffect.Descriptor[] desc = AudioEffect.queryEffects();
// ++++++++++++++++++++++++++++Descriptor++++++++++++++++++++++++++++++++++++
    /**
     * The effect descriptor contains information on a particular effect implemented in the
     * audio framework:<br>
     * <ul>
     *  <li>type: UUID corresponding to the OpenSL ES interface implemented by this effect</li>
     *  <li>uuid: UUID for this particular implementation</li>
     *  <li>connectMode: {@link #EFFECT_INSERT} or {@link #EFFECT_AUXILIARY}</li>
     *  <li>name: human readable effect name</li>
     *  <li>implementor: human readable effect implementor name</li>
     * </ul>
     * The method {@link #queryEffects()} returns an array of Descriptors to facilitate effects
     * enumeration.
     */
    public static class Descriptor {


        public Descriptor() {
        }


        public Descriptor(String type, String uuid, String connectMode,
                String name, String implementor) {
            this.type = UUID.fromString(type);
            this.uuid = UUID.fromString(uuid);
            this.connectMode = connectMode;
            this.name = name;
            this.implementor = implementor;
        }


        /**
         *  Indicates the generic type of the effect (Equalizer, Bass boost ...). The UUID
         *  corresponds to the OpenSL ES Interface ID for this type of effect.
         */
        public UUID type;
        /**
         *  Indicates the particular implementation of the effect in that type. Several effects
         *  can have the same type but this uuid is unique to a given implementation.
         */
// 上次看AudioEffect类的时候，对type和uuid的区别还不是很清楚
// 看了这儿的注释，就比较清楚了
        public UUID uuid;
        /**
         *  Indicates if the effect is of insert category {@link #EFFECT_INSERT} or auxiliary
         *  category {@link #EFFECT_AUXILIARY}. Insert effects (Typically an Equalizer) are applied
         *  to the entire audio source and usually not shared by several sources. Auxiliary effects
         *  (typically a reverberator) are applied to part of the signal (wet) and the effect output
         *  is added to the original signal (dry).
         */
        public String connectMode;
        /**
         * Human readable effect name
         */
        public String name;
        /**
         * Human readable effect implementor name
         */
        public String implementor;
    };
// ----------------------------Descriptor------------------------------------
// ++++++++++++++++++++++++++++queryEffects++++++++++++++++++++++++++++++++++++
    /**
     * Query all effects available on the platform. Returns an array of
     * {@link android.media.audiofx.AudioEffect.Descriptor} objects
     *
     * @throws IllegalStateException
     */


    static public Descriptor[] queryEffects() {
        return (Descriptor[]) native_query_effects();
// +++++++++++++++++++++++++++android_media_AudioEffect_native_queryEffects+++++++++++++++++++++++++++++++++++++
static jobjectArray
android_media_AudioEffect_native_queryEffects(JNIEnv *env, jclass clazz)
{
    effect_descriptor_t desc;
    char str[EFFECT_STRING_LEN_MAX];
    uint32_t numEffects;
    uint32_t i = 0;
    jstring jdescType;
    jstring jdescUuid;
    jstring jdescConnect;
    jstring jdescName;
    jstring jdescImplementor;
    jobject jdesc;


    AudioEffect::queryNumberEffects(&numEffects);
// ++++++++++++++++++++++++++++AudioEffect::queryNumberEffects++++++++++++++++++++++++++++++++++++
status_t AudioEffect::queryNumberEffects(uint32_t *numEffects)
{
    const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
    if (af == 0) return PERMISSION_DENIED;
    return af->queryNumberEffects(numEffects);
// ++++++++++++++++++++++++++++AudioFlinger::queryNumberEffects++++++++++++++++++++++++++++++++++++
status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects)
{
    Mutex::Autolock _l(mLock);
    return EffectQueryNumberEffects(numEffects);
// ++++++++++++++++++++++++++EffectQueryNumberEffects++++++++++++++++++++++++++++++++++++++
// 函数EffectQueryNumberEffects定义的地方比较多。
// 我们使用的应该是下面这个文件中的：
// frameworks\base\media\libeffects\factory\


int EffectQueryNumberEffects(uint32_t *pNumEffects)
{
    int ret = init();
    if (ret < 0) {
        return ret;
    }
    if (pNumEffects == NULL) {
        return -EINVAL;
    }


    pthread_mutex_lock(&gLibLock);
// gNumEffects在函数updateNumEffects中有对其赋值
    *pNumEffects = gNumEffects;
// ++++++++++++++++++++++++++++++updateNumEffects++++++++++++++++++++++++++++++++++
uint32_t updateNumEffects() {
    list_elem_t *e;
    uint32_t cnt = 0;


    resetEffectEnumeration();
// ++++++++++++++++++++++++++++++resetEffectEnumeration++++++++++++++++++++++++++++++++++
void resetEffectEnumeration()
{
    gCurLib = gLibraryList;
    gCurEffect = NULL;
    if (gCurLib) {
        gCurEffect = ((lib_entry_t *)gCurLib->object)->effects;
    }
    gCurEffectIdx = 0;
}
// ------------------------------resetEffectEnumeration----------------------------------


// 函数EffectCreate和函数loadLibrary会向gLibraryList中添加成员
// 函数EffectRelease和函数unloadLibrary会删除gLibraryList中的成员
    e = gLibraryList;
// +++++++++++++++++++++++++++++++EffectCreate+++++++++++++++++++++++++++++++++
int EffectCreate(effect_uuid_t *uuid, int32_t sessionId, int32_t ioId, effect_interface_t *pInterface)
{
    list_elem_t *e = gLibraryList;
    lib_entry_t *l = NULL;
    effect_descriptor_t *d = NULL;
    effect_interface_t itfe;
    effect_entry_t *fx;
    int found = 0;
    int ret;


    if (uuid == NULL || pInterface == NULL) {
        return -EINVAL;
    }


    LOGV("EffectCreate() UUID: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n",
            uuid->timeLow, uuid->timeMid, uuid->timeHiAndVersion,
            uuid->clockSeq, uuid->node[0], uuid->node[1],uuid->node[2],
            uuid->node[3],uuid->node[4],uuid->node[5]);


    ret = init();
// ++++++++++++++++++++++++++++init++++++++++++++++++++++++++++++++++++
int init() {
    struct dirent *ent;
    DIR *dir = NULL;
    char libpath[PATH_MAX];
    int hdl;


// 避免重复初始化 
    if (gInitDone) {
        return 0;
    }


    pthread_mutex_init(&gLibLock, NULL);


    // load built-in libraries
// const char * const gEffectLibPath = "/system/lib/soundfx"; // path to built-in effect libraries
    dir = opendir(gEffectLibPath);
    if (dir == NULL) {
        return -ENODEV;
    }
    while ((ent = readdir(dir)) != NULL) {
        LOGV("init() reading file %s", ent->d_name);
        if ((strlen(ent->d_name) < 3) ||
            strncmp(ent->d_name, "lib", 3) != 0 ||
            strncmp(ent->d_name + strlen(ent->d_name) - 3, ".so", 3) != 0) {
            continue;
        }
        strcpy(libpath, gEffectLibPath);
        strcat(libpath, "/");
        strcat(libpath, ent->d_name);
// loadlibrary会向gLibraryList中添加成员
// 也就是说，在初始化阶段，会将built-in的effect libraries打开并添加到gLibraryList中
        if (loadLibrary(libpath, &hdl) < 0) {
            LOGW("init() failed to load library %s",libpath);
        }
    }
    closedir(dir);
// 更新effects的个数
    updateNumEffects();
    gInitDone = 1;
    LOGV("init() done");
    return 0;
}
// ----------------------------init------------------------------------


    if (ret < 0) {
        LOGW("EffectCreate() init error: %d", ret);
        return ret;
    }


    pthread_mutex_lock(&gLibLock);


// 根据uuid寻找对应的effect lib
// 若没有找到，则说明对应的effect lib不存在，也就没办法创建effect
// 如找到了，则使用对应的effect lib创建effect
    ret = findEffect(uuid, &l, &d);
    if (ret < 0){
        goto exit;
    }
// ++++++++++++++++++++++++++++++findEffect++++++++++++++++++++++++++++++++++
int findEffect(effect_uuid_t *uuid, lib_entry_t **lib, effect_descriptor_t **desc)
{
    list_elem_t *e = gLibraryList;
    lib_entry_t *l = NULL;
    effect_descriptor_t *d = NULL;
    int found = 0;
    int ret = 0;


    while (e && !found) {
        l = (lib_entry_t *)e->object;
        list_elem_t *efx = l->effects;
        while (efx) {
            d = (effect_descriptor_t *)efx->object;
            if (memcmp(&d->uuid, uuid, sizeof(effect_uuid_t)) == 0) {
                found = 1;
                break;
            }
            efx = efx->next;
        }
        e = e->next;
    }
    if (!found) {
        LOGV("findEffect() effect not found");
        ret = -ENOENT;
    } else {
        LOGV("findEffect() found effect: %s in lib %s", d->name, l->path);
        *lib = l;
        *desc = d;
    }


    return ret;
}
// ------------------------------findEffect----------------------------------


    // create effect in library
// createFx的赋值是中loadLibrary函数中完成：createFx = (effect_CreateEffect_t)dlsym(hdl, "EffectCreate");
    ret = l->createFx(uuid, sessionId, ioId, &itfe);
    if (ret != 0) {
        LOGW("EffectCreate() library %s: could not create fx %s, error %d", l->path, d->name, ret);
        goto exit;
    }
// +++++++++++++++++++++++++++EffectReverb EffectCreate+++++++++++++++++++++++++++++++++++++
我们看看EffectReverb中的EffectCreate函数。


int EffectCreate(effect_uuid_t *uuid,
        int32_t sessionId,
        int32_t ioId,
        effect_interface_t *pInterface) {
    int ret;
    int i;
    reverb_module_t *module;
    const effect_descriptor_t *desc;
    int aux = 0;
    int preset = 0;


    LOGV("EffectLibCreateEffect start");


    if (pInterface == NULL || uuid == NULL) {
        return -EINVAL;
    }


    for (i = 0; gDescriptors[i] != NULL; i++) {
        desc = gDescriptors[i];
        if (memcmp(uuid, &desc->uuid, sizeof(effect_uuid_t))
                == 0) {
            break;
        }
    }


    if (gDescriptors[i] == NULL) {
        return -ENOENT;
    }


    module = malloc(sizeof(reverb_module_t));


    module->itfe = &gReverbInterface;
// ++++++++++++++++++++++++++++++++gReverbInterface++++++++++++++++++++++++++++++++
// effect_interface_t interface implementation for reverb effect
const struct effect_interface_s gReverbInterface = {
        Reverb_Process,
        Reverb_Command
};
// --------------------------------gReverbInterface--------------------------------


    module->context.mState = REVERB_STATE_UNINITIALIZED;


    if (memcmp(&desc->type, SL_IID_PRESETREVERB, sizeof(effect_uuid_t)) == 0) {
        preset = 1;
    }
// ++++++++++++++++++++++++++++++++SL_IID_PRESETREVERB++++++++++++++++++++++++++++++++
#ifndef OPENSL_ES_H_
static const effect_uuid_t SL_IID_PRESETREVERB_ = { 0x47382d60, 0xddd8, 0x11db, 0xbf3a, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
const effect_uuid_t * const SL_IID_PRESETREVERB = &SL_IID_PRESETREVERB_;
#endif //OPENSL_ES_H_
// --------------------------------SL_IID_PRESETREVERB--------------------------------
    if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
        aux = 1;
    }
    ret = Reverb_Init(module, aux, preset);
    if (ret < 0) {
        LOGW("EffectLibCreateEffect() init failed");
        free(module);
        return ret;
    }
// +++++++++++++++++++++++++++++Reverb_Init+++++++++++++++++++++++++++++++++++
/*----------------------------------------------------------------------------
 * Reverb_Init()
 *----------------------------------------------------------------------------
 * Purpose:
 * Initialize reverb context and apply default parameters
 *
 * Inputs:
 *  pRvbModule    - pointer to reverb effect module
 *  aux           - indicates if the reverb is used as auxiliary (1) or insert (0)
 *  preset        - indicates if the reverb is used in preset (1) or environmental (0) mode
 *
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
 */


int Reverb_Init(reverb_module_t *pRvbModule, int aux, int preset) {
    int ret;


    LOGV("Reverb_Init module %p, aux: %d, preset: %d", pRvbModule,aux, preset);


    memset(&pRvbModule->context, 0, sizeof(reverb_object_t));


    pRvbModule->context.m_Aux = (uint16_t)aux;
    pRvbModule->context.m_Preset = (uint16_t)preset;


    pRvbModule->config.inputCfg.samplingRate = 44100;
    if (aux) {
        pRvbModule->config.inputCfg.channels = CHANNEL_MONO;
    } else {
        pRvbModule->config.inputCfg.channels = CHANNEL_STEREO;
    }
    pRvbModule->config.inputCfg.format = SAMPLE_FORMAT_PCM_S15;
    pRvbModule->config.inputCfg.bufferProvider.getBuffer = NULL;
    pRvbModule->config.inputCfg.bufferProvider.releaseBuffer = NULL;
    pRvbModule->config.inputCfg.bufferProvider.cookie = NULL;
    pRvbModule->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
    pRvbModule->config.inputCfg.mask = EFFECT_CONFIG_ALL;
    pRvbModule->config.outputCfg.samplingRate = 44100;
    pRvbModule->config.outputCfg.channels = CHANNEL_STEREO;
    pRvbModule->config.outputCfg.format = SAMPLE_FORMAT_PCM_S15;
    pRvbModule->config.outputCfg.bufferProvider.getBuffer = NULL;
    pRvbModule->config.outputCfg.bufferProvider.releaseBuffer = NULL;
    pRvbModule->config.outputCfg.bufferProvider.cookie = NULL;
    pRvbModule->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
    pRvbModule->config.outputCfg.mask = EFFECT_CONFIG_ALL;


    ret = Reverb_Configure(pRvbModule, &pRvbModule->config, true);
    if (ret < 0) {
        LOGV("Reverb_Init error %d on module %p", ret, pRvbModule);
    }
// +++++++++++++++++++++++++Reverb_Configure+++++++++++++++++++++++++++++++++++++++
/*----------------------------------------------------------------------------
 * Reverb_Init()
 *----------------------------------------------------------------------------
 * Purpose:
 *  Set input and output audio configuration.
 *
 * Inputs:
 *  pRvbModule    - pointer to reverb effect module
 *  pConfig       - pointer to effect_config_t structure containing input
 *              and output audio parameters configuration
 *  init          - true if called from init function
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
 */


int Reverb_Configure(reverb_module_t *pRvbModule, effect_config_t *pConfig,
        bool init) {
    reverb_object_t *pReverb = &pRvbModule->context;
    int bufferSizeInSamples;
    int updatePeriodInSamples;
    int xfadePeriodInSamples;


    // Check configuration compatibility with build options
    if (pConfig->inputCfg.samplingRate
        != pConfig->outputCfg.samplingRate
        || pConfig->outputCfg.channels != OUTPUT_CHANNELS
        || pConfig->inputCfg.format != SAMPLE_FORMAT_PCM_S15
        || pConfig->outputCfg.format != SAMPLE_FORMAT_PCM_S15) {
        LOGV("Reverb_Configure invalid config");
        return -EINVAL;
    }
    if ((pReverb->m_Aux && (pConfig->inputCfg.channels != CHANNEL_MONO)) ||
        (!pReverb->m_Aux && (pConfig->inputCfg.channels != CHANNEL_STEREO))) {
        LOGV("Reverb_Configure invalid config");
        return -EINVAL;
    }


    memcpy(&pRvbModule->config, pConfig, sizeof(effect_config_t));


    pReverb->m_nSamplingRate = pRvbModule->config.outputCfg.samplingRate;


    switch (pReverb->m_nSamplingRate) {
    case 8000:
        pReverb->m_nUpdatePeriodInBits = 5;
        bufferSizeInSamples = 4096;
        pReverb->m_nCosWT_5KHz = -23170;
        break;
    case 16000:
        pReverb->m_nUpdatePeriodInBits = 6;
        bufferSizeInSamples = 8192;
        pReverb->m_nCosWT_5KHz = -12540;
        break;
    case 22050:
        pReverb->m_nUpdatePeriodInBits = 7;
        bufferSizeInSamples = 8192;
        pReverb->m_nCosWT_5KHz = 4768;
        break;
    case 32000:
        pReverb->m_nUpdatePeriodInBits = 7;
        bufferSizeInSamples = 16384;
        pReverb->m_nCosWT_5KHz = 18205;
        break;
    case 44100:
        pReverb->m_nUpdatePeriodInBits = 8;
        bufferSizeInSamples = 16384;
        pReverb->m_nCosWT_5KHz = 24799;
        break;
    case 48000:
        pReverb->m_nUpdatePeriodInBits = 8;
        bufferSizeInSamples = 16384;
        pReverb->m_nCosWT_5KHz = 25997;
        break;
    default:
        LOGV("Reverb_Configure invalid sampling rate %d", pReverb->m_nSamplingRate);
        return -EINVAL;
    }


    // Define a mask for circular addressing, so that array index
    // can wraparound and stay in array boundary of 0, 1, ..., (buffer size -1)
    // The buffer size MUST be a power of two
    pReverb->m_nBufferMask = (int32_t) (bufferSizeInSamples - 1);
    /* reverb parameters are updated every 2^(pReverb->m_nUpdatePeriodInBits) samples */
    updatePeriodInSamples = (int32_t) (0x1L << pReverb->m_nUpdatePeriodInBits);
    /*
     calculate the update counter by bitwise ANDING with this value to
     generate a 2^n modulo value
     */
    pReverb->m_nUpdatePeriodInSamples = (int32_t) updatePeriodInSamples;


    xfadePeriodInSamples = (int32_t) (REVERB_XFADE_PERIOD_IN_SECONDS
            * (double) pReverb->m_nSamplingRate);


    // set xfade parameters
    pReverb->m_nPhaseIncrement
            = (int16_t) (65536 / ((int16_t) xfadePeriodInSamples
                    / (int16_t) updatePeriodInSamples));


    if (init) {
        ReverbReadInPresets(pReverb);
// +++++++++++++++++++++++++++++ReverbReadInPresets+++++++++++++++++++++++++++++++++++
// 函数内容没有太多要介绍的，只列出其注释。


/*----------------------------------------------------------------------------
 * ReverbReadInPresets()
 *----------------------------------------------------------------------------
 * Purpose: sets global reverb preset bank to defaults
 *
 * Inputs:
 *
 * Outputs:
 *
 *----------------------------------------------------------------------------
 */
// -----------------------------ReverbReadInPresets-----------------------------------


        // for debugging purposes, allow noise generator
        pReverb->m_bUseNoise = true;


        // for debugging purposes, allow bypass
        pReverb->m_bBypass = 0;


        pReverb->m_nNextRoom = 1;


        pReverb->m_nNoise = (int16_t) 0xABCD;
    }


    Reverb_Reset(pReverb, init);
// +++++++++++++++++++++++++++++Reverb_Reset+++++++++++++++++++++++++++++++++++
/*----------------------------------------------------------------------------
 * Reverb_Reset()
 *----------------------------------------------------------------------------
 * Purpose:
 *  Reset internal states and clear delay lines.
 *
 * Inputs:
 *  pReverb    - pointer to reverb context
 *  init       - true if called from init function
 *
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
 */


void Reverb_Reset(reverb_object_t *pReverb, bool init) {
    int bufferSizeInSamples = (int32_t) (pReverb->m_nBufferMask + 1);
    int maxApSamples;
    int maxDelaySamples;
    int maxEarlySamples;
    int ap1In;
    int delay0In;
    int delay1In;
    int32_t i;
    uint16_t nOffset;


    maxApSamples = ((int32_t) (MAX_AP_TIME * pReverb->m_nSamplingRate) >> 16);
    maxDelaySamples = ((int32_t) (MAX_DELAY_TIME * pReverb->m_nSamplingRate)
            >> 16);
    maxEarlySamples = ((int32_t) (MAX_EARLY_TIME * pReverb->m_nSamplingRate)
            >> 16);


    ap1In = (AP0_IN + maxApSamples + GUARD);
    delay0In = (ap1In + maxApSamples + GUARD);
    delay1In = (delay0In + maxDelaySamples + GUARD);
    // Define the max offsets for the end points of each section
    // i.e., we don't expect a given section's taps to go beyond
    // the following limits


    pReverb->m_nEarly0in = (delay1In + maxDelaySamples + GUARD);
    pReverb->m_nEarly1in = (pReverb->m_nEarly0in + maxEarlySamples + GUARD);


    pReverb->m_sAp0.m_zApIn = AP0_IN;


    pReverb->m_zD0In = delay0In;


    pReverb->m_sAp1.m_zApIn = ap1In;


    pReverb->m_zD1In = delay1In;


    pReverb->m_zOutLpfL = 0;
    pReverb->m_zOutLpfR = 0;


    pReverb->m_nRevFbkR = 0;
    pReverb->m_nRevFbkL = 0;


    // set base index into circular buffer
    pReverb->m_nBaseIndex = 0;


    // clear the reverb delay line
    for (i = 0; i < bufferSizeInSamples; i++) {
        pReverb->m_nDelayLine[i] = 0;
    }


    ReverbUpdateRoom(pReverb, init);
// +++++++++++++++++++++++++++++++ReverbUpdateRoom+++++++++++++++++++++++++++++++++
/*----------------------------------------------------------------------------
 * ReverbUpdateRoom
 *----------------------------------------------------------------------------
 * Purpose:
 * Update the room's preset parameters as required
 *
 * Inputs:
 *
 * Outputs:
 *
 *
 * Side Effects:
 * - reverb paramters (fbk, fwd, etc) will be changed
 * - m_nCurrentRoom := m_nNextRoom
 *----------------------------------------------------------------------------
 */
static int ReverbUpdateRoom(reverb_object_t *pReverb, bool fullUpdate) {
    int temp;
    int i;
    int maxSamples;
    int earlyDelay;
    int earlyGain;


    reverb_preset_t *pPreset =
            &pReverb->m_sPreset.m_sPreset[pReverb->m_nNextRoom];


    if (fullUpdate) {
        pReverb->m_nRvbLpfFwd = pPreset->m_nRvbLpfFwd;
        pReverb->m_nRvbLpfFbk = pPreset->m_nRvbLpfFbk;


        pReverb->m_nEarlyGain = pPreset->m_nEarlyGain;
        //stored as time based, convert to sample based
        pReverb->m_nLateGain = pPreset->m_nLateGain;
        pReverb->m_nRoomLpfFbk = pPreset->m_nRoomLpfFbk;
        pReverb->m_nRoomLpfFwd = pPreset->m_nRoomLpfFwd;


        // set the early reflections gains
        earlyGain = pPreset->m_nEarlyGain;
        for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) {
            pReverb->m_sEarlyL.m_nGain[i]
                    = MULT_EG1_EG1(pPreset->m_sEarlyL.m_nGain[i],earlyGain);
            pReverb->m_sEarlyR.m_nGain[i]
                    = MULT_EG1_EG1(pPreset->m_sEarlyR.m_nGain[i],earlyGain);
        }


        pReverb->m_nMaxExcursion = pPreset->m_nMaxExcursion;


        pReverb->m_sAp0.m_nApGain = pPreset->m_nAp0_ApGain;
        pReverb->m_sAp1.m_nApGain = pPreset->m_nAp1_ApGain;


        // set the early reflections delay
        earlyDelay = ((int) pPreset->m_nEarlyDelay * pReverb->m_nSamplingRate)
                >> 16;
        pReverb->m_nEarlyDelay = earlyDelay;
        maxSamples = (int32_t) (MAX_EARLY_TIME * pReverb->m_nSamplingRate)
                >> 16;
        for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) {
            //stored as time based, convert to sample based
            temp = earlyDelay + (((int) pPreset->m_sEarlyL.m_zDelay[i]
                    * pReverb->m_nSamplingRate) >> 16);
            if (temp > maxSamples)
                temp = maxSamples;
            pReverb->m_sEarlyL.m_zDelay[i] = pReverb->m_nEarly0in + temp;
            //stored as time based, convert to sample based
            temp = earlyDelay + (((int) pPreset->m_sEarlyR.m_zDelay[i]
                    * pReverb->m_nSamplingRate) >> 16);
            if (temp > maxSamples)
                temp = maxSamples;
            pReverb->m_sEarlyR.m_zDelay[i] = pReverb->m_nEarly1in + temp;
        }


        maxSamples = (int32_t) (MAX_DELAY_TIME * pReverb->m_nSamplingRate)
                >> 16;
        //stored as time based, convert to sample based
        /*lint -e{702} shift for performance */
        temp = (pPreset->m_nLateDelay * pReverb->m_nSamplingRate) >> 16;
        if ((temp + pReverb->m_nMaxExcursion) > maxSamples) {
            temp = maxSamples - pReverb->m_nMaxExcursion;
        }
        temp -= pReverb->m_nLateDelay;
        pReverb->m_nDelay0Out += temp;
        pReverb->m_nDelay1Out += temp;
        pReverb->m_nLateDelay += temp;


        maxSamples = (int32_t) (MAX_AP_TIME * pReverb->m_nSamplingRate) >> 16;
        //stored as time based, convert to absolute sample value
        temp = pPreset->m_nAp0_ApOut;
        /*lint -e{702} shift for performance */
        temp = (temp * pReverb->m_nSamplingRate) >> 16;
        if (temp > maxSamples)
            temp = maxSamples;
        pReverb->m_sAp0.m_zApOut = (uint16_t) (pReverb->m_sAp0.m_zApIn + temp);


        //stored as time based, convert to absolute sample value
        temp = pPreset->m_nAp1_ApOut;
        /*lint -e{702} shift for performance */
        temp = (temp * pReverb->m_nSamplingRate) >> 16;
        if (temp > maxSamples)
            temp = maxSamples;
        pReverb->m_sAp1.m_zApOut = (uint16_t) (pReverb->m_sAp1.m_zApIn + temp);
        //gpsReverbObject->m_sAp1.m_zApOut = pPreset->m_nAp1_ApOut;
    }


    //stored as time based, convert to sample based
    temp = pPreset->m_nXfadeInterval;
    /*lint -e{702} shift for performance */
    temp = (temp * pReverb->m_nSamplingRate) >> 16;
    pReverb->m_nXfadeInterval = (uint16_t) temp;
    //gsReverbObject.m_nXfadeInterval = pPreset->m_nXfadeInterval;
    pReverb->m_nXfadeCounter = pReverb->m_nXfadeInterval + 1; // force update on first iteration


    pReverb->m_nCurrentRoom = pReverb->m_nNextRoom;


    return 0;


} /* end ReverbUpdateRoom */
// -------------------------------ReverbUpdateRoom---------------------------------


    pReverb->m_nUpdateCounter = 0;


    pReverb->m_nPhase = -32768;


    pReverb->m_nSin = 0;
    pReverb->m_nCos = 0;
    pReverb->m_nSinIncrement = 0;
    pReverb->m_nCosIncrement = 0;


    // set delay tap lengths
    nOffset = ReverbCalculateNoise(pReverb);
// ++++++++++++++++++++++++++++ReverbCalculateNoise++++++++++++++++++++++++++++++++++++
/*----------------------------------------------------------------------------
 * ReverbCalculateNoise
 *----------------------------------------------------------------------------
 * Purpose:
 * Calculate a noise sample and limit its value
 *
 * Inputs:
 * nMaxExcursion - noise value is limited to this value
 * pnNoise - return new noise sample in this (not limited)
 *
 * Outputs:
 * new limited noise value
 *
 * Side Effects:
 * - *pnNoise noise value is updated
 *
 *----------------------------------------------------------------------------
 */
static uint16_t ReverbCalculateNoise(reverb_object_t *pReverb) {
    int16_t nNoise = pReverb->m_nNoise;


    // calculate new noise value
    if (pReverb->m_bUseNoise) {
        nNoise = (int16_t) (nNoise * 5 + 1);
    } else {
        nNoise = 0;
    }


    pReverb->m_nNoise = nNoise;
    // return the limited noise value
    return (pReverb->m_nMaxExcursion & nNoise);


} /* end ReverbCalculateNoise */
// ----------------------------ReverbCalculateNoise------------------------------------


    pReverb->m_zD1Cross = pReverb->m_nDelay1Out - pReverb->m_nMaxExcursion
            + nOffset;


    nOffset = ReverbCalculateNoise(pReverb);


    pReverb->m_zD0Cross = pReverb->m_nDelay0Out - pReverb->m_nMaxExcursion
            - nOffset;


    nOffset = ReverbCalculateNoise(pReverb);


    pReverb->m_zD0Self = pReverb->m_nDelay0Out - pReverb->m_nMaxExcursion
            - nOffset;


    nOffset = ReverbCalculateNoise(pReverb);


    pReverb->m_zD1Self = pReverb->m_nDelay1Out - pReverb->m_nMaxExcursion
            + nOffset;
}
// -----------------------------Reverb_Reset-----------------------------------


    return 0;
}
// -------------------------Reverb_Configure---------------------------------------


    return ret;
}
// -----------------------------Reverb_Init-----------------------------------


    *pInterface = (effect_interface_t) module;


    module->context.mState = REVERB_STATE_INITIALIZED;


    LOGV("EffectLibCreateEffect %p ,size %d", module, sizeof(reverb_module_t));


    return 0;
}
// ---------------------------EffectReverb EffectCreate-------------------------------------


    // add entry to effect list
    fx = (effect_entry_t *)malloc(sizeof(effect_entry_t));
    fx->subItfe = itfe;
    fx->itfe = (struct effect_interface_s *)&gInterface;
    fx->lib = l;


    e = (list_elem_t *)malloc(sizeof(list_elem_t));
    e->object = fx;
    e->next = gEffectList;
    gEffectList = e;


    *pInterface = (effect_interface_t)fx;


    LOGV("EffectCreate() created entry %p with sub itfe %p in library %s", *pInterface, itfe, l->path);


exit:
    pthread_mutex_unlock(&gLibLock);
    return ret;
}
// -------------------------------EffectCreate---------------------------------
// ++++++++++++++++++++++++++++++loadLibrary++++++++++++++++++++++++++++++++++
int loadLibrary(const char *libPath, int *handle)
{
    void *hdl;
    effect_QueryNumberEffects_t queryNumFx;
    effect_QueryEffect_t queryFx;
    effect_CreateEffect_t createFx;
    effect_ReleaseEffect_t releaseFx;
    uint32_t numFx;
    uint32_t fx;
    int ret;
    list_elem_t *e, *descHead = NULL;
    lib_entry_t *l;


    if (handle == NULL) {
        return -EINVAL;
    }


    *handle = 0;


    hdl = dlopen(libPath, RTLD_NOW);
    if (hdl == 0) {
        LOGW("could open lib %s", libPath);
        return -ENODEV;
    }


    // Check functions availability
    queryNumFx = (effect_QueryNumberEffects_t)dlsym(hdl, "EffectQueryNumberEffects");
    if (queryNumFx == NULL) {
        LOGW("could not get EffectQueryNumberEffects from lib %s", libPath);
        ret = -ENODEV;
        goto error;
    }
    queryFx = (effect_QueryEffect_t)dlsym(hdl, "EffectQueryEffect");
    if (queryFx == NULL) {
        LOGW("could not get EffectQueryEffect from lib %s", libPath);
        ret = -ENODEV;
        goto error;
    }
    createFx = (effect_CreateEffect_t)dlsym(hdl, "EffectCreate");
    if (createFx == NULL) {
        LOGW("could not get EffectCreate from lib %s", libPath);
        ret = -ENODEV;
        goto error;
    }
    releaseFx = (effect_ReleaseEffect_t)dlsym(hdl, "EffectRelease");
    if (releaseFx == NULL) {
        LOGW("could not get EffectRelease from lib %s", libPath);
        ret = -ENODEV;
        goto error;
    }


    // load effect descriptors
    ret = queryNumFx(&numFx);
    if (ret) {
        goto error;
    }


    for (fx = 0; fx < numFx; fx++) {
        effect_descriptor_t *d = malloc(sizeof(effect_descriptor_t));
        if (d == NULL) {
            ret = -ENOMEM;
            goto error;
        }
        ret = queryFx(fx, d);
        if (ret == 0) {
#if (LOG_NDEBUG==0)
            char s[256];
            dumpEffectDescriptor(d, s, 256);
            LOGV("loadLibrary() read descriptor %p:%s",d, s);
#endif
            if (d->apiVersion != EFFECT_API_VERSION) {
                LOGW("Bad API version %04x on lib %s", d->apiVersion, libPath);
                free(d);
                continue;
            }
            e = malloc(sizeof(list_elem_t));
            if (e == NULL) {
                free(d);
                ret = -ENOMEM;
                goto error;
            }
            e->object = d;
            e->next = descHead;
            descHead = e;
        } else {
            LOGW("Error querying effect # %d on lib %s", fx, libPath);
        }
    }


    pthread_mutex_lock(&gLibLock);


    // add entry for library in gLibraryList
    l = malloc(sizeof(lib_entry_t));
    l->id = ++gNextLibId;
    l->handle = hdl;
    strncpy(l->path, libPath, PATH_MAX);
    l->createFx = createFx;
    l->releaseFx = releaseFx;
    l->effects = descHead;
    pthread_mutex_init(&l->lock, NULL);


    e = malloc(sizeof(list_elem_t));
    e->next = gLibraryList;
    e->object = l;
    gLibraryList = e;
    pthread_mutex_unlock(&gLibLock);
    LOGV("loadLibrary() linked library %p", l);


    *handle = l->id;


    return 0;


error:
    LOGW("loadLibrary() error: %d on lib: %s", ret, libPath);
    while (descHead) {
        free(descHead->object);
        e = descHead->next;
        free(descHead);
        descHead = e;;
    }
    dlclose(hdl);
    return ret;
}


// 我们已经知道，init函数中有调用loadLibrary，另外，EffectLoadLibrary中也有调用loadLibrary函数。
// ++++++++++++++++++++++++++++++EffectLoadLibrary++++++++++++++++++++++++++++++++++
int EffectLoadLibrary(const char *libPath, int *handle)
{
    int ret = init();
    if (ret < 0) {
        return ret;
    }
    if (libPath == NULL) {
        return -EINVAL;
    }


    ret = loadLibrary(libPath, handle);
    updateNumEffects();
    return ret;
}


// 函数AudioFlinger::loadEffectLibrary中调用了函数EffectLoadLibrary
// +++++++++++++++++++++++++++++AudioFlinger::loadEffectLibrary+++++++++++++++++++++++++++++++++++
status_t AudioFlinger::loadEffectLibrary(const char *libPath, int *handle)
{
    // check calling permissions
    if (!settingsAllowed()) {
        return PERMISSION_DENIED;
    }
    // only allow libraries loaded from /system/lib/soundfx for now
    if (strncmp(gEffectLibPath, libPath, strlen(gEffectLibPath)) != 0) {
        return PERMISSION_DENIED;
    }


    Mutex::Autolock _l(mLock);
    return EffectLoadLibrary(libPath, handle);
}
// -----------------------------AudioFlinger::loadEffectLibrary-----------------------------------
// ------------------------------EffectLoadLibrary----------------------------------
// ------------------------------loadLibrary----------------------------------
// +++++++++++++++++++++++++++++EffectRelease+++++++++++++++++++++++++++++++++++
int EffectRelease(effect_interface_t interface)
{
    effect_entry_t *fx;
    list_elem_t *e1;
    list_elem_t *e2;


    int ret = init();
    if (ret < 0) {
        return ret;
    }


    // remove effect from effect list
    pthread_mutex_lock(&gLibLock);
    e1 = gEffectList;
    e2 = NULL;
    while (e1) {
        if (e1->object == interface) {
            if (e2) {
                e2->next = e1->next;
            } else {
                gEffectList = e1->next;
            }
            fx = (effect_entry_t *)e1->object;
            free(e1);
            break;
        }
        e2 = e1;
        e1 = e1->next;
    }
    if (e1 == NULL) {
        ret = -ENOENT;
        goto exit;
    }


    // release effect in library
    if (fx->lib == NULL) {
        LOGW("EffectRelease() fx %p library already unloaded", interface);
    } else {
        pthread_mutex_lock(&fx->lib->lock);
        fx->lib->releaseFx(fx->subItfe);
        pthread_mutex_unlock(&fx->lib->lock);
    }
    free(fx);


exit:
    pthread_mutex_unlock(&gLibLock);
    return ret;
}
// -----------------------------EffectRelease-----------------------------------
// +++++++++++++++++++++++++++++unloadLibrary+++++++++++++++++++++++++++++++++++
int unloadLibrary(int handle)
{
    void *hdl;
    int ret;
    list_elem_t *el1, *el2;
    lib_entry_t *l;
    effect_entry_t *fx;


    pthread_mutex_lock(&gLibLock);
    el1 = gLibraryList;
    el2 = NULL;
    while (el1) {
        l = (lib_entry_t *)el1->object;
        if (handle == l->id) {
            if (el2) {
                el2->next = el1->next;
            } else {
                gLibraryList = el1->next;
            }
            free(el1);
            break;
        }
        el2 = el1;
        el1 = el1->next;
    }
    pthread_mutex_unlock(&gLibLock);
    if (el1 == NULL) {
        return -ENOENT;
    }


    // clear effect descriptor list
    el1 = l->effects;
    while (el1) {
        free(el1->object);
        el2 = el1->next;
        free(el1);
        el1 = el2;
    }


    // disable all effects from this library
    pthread_mutex_lock(&l->lock);


    el1 = gEffectList;
    while (el1) {
        fx = (effect_entry_t *)el1->object;
        if (fx->lib == l) {
            fx->lib = NULL;
        }
        el1 = el1->next;
    }
    pthread_mutex_unlock(&l->lock);


    dlclose(l->handle);
    free(l);
    return 0;
}


// 函数EffectUnloadLibrary调用了unloadLibrary函数。
// +++++++++++++++++++++++++++++EffectUnloadLibrary+++++++++++++++++++++++++++++++++++
int EffectUnloadLibrary(int handle)
{
    int ret = init();
    if (ret < 0) {
        return ret;
    }


    ret = unloadLibrary(handle);
    updateNumEffects();
    return ret;
}


// 函数AudioFlinger::unloadEffectLibrary中有调用了EffectUnloadLibrary函数。
// +++++++++++++++++++++++++++++AudioFlinger::unloadEffectLibrary+++++++++++++++++++++++++++++++++++
status_t AudioFlinger::unloadEffectLibrary(int handle)
{
    // check calling permissions
    if (!settingsAllowed()) {
        return PERMISSION_DENIED;
    }


    Mutex::Autolock _l(mLock);
    return EffectUnloadLibrary(handle);
}
// -----------------------------AudioFlinger::unloadEffectLibrary-----------------------------------
// -----------------------------EffectUnloadLibrary-----------------------------------
// -----------------------------unloadLibrary-----------------------------------
    while (e) {
        lib_entry_t *l = (lib_entry_t *)e->object;
        list_elem_t *efx = l->effects;
        while (efx) {
            cnt++;
            efx = efx->next;
        }
        e = e->next;
    }
    gNumEffects = cnt;
    gCanQueryEffect = 0;
    return cnt;
}
// ------------------------------updateNumEffects----------------------------------
    gCanQueryEffect = 1;
    pthread_mutex_unlock(&gLibLock);
    LOGV("EffectQueryNumberEffects(): %d", *pNumEffects);
    return ret;
}
// --------------------------EffectQueryNumberEffects--------------------------------------
}
// ----------------------------AudioFlinger::queryNumberEffects------------------------------------
}
// ----------------------------AudioEffect::queryNumberEffects------------------------------------
    jobjectArray ret = env->NewObjectArray(numEffects, fields.clazzDesc, NULL);
    if (ret == NULL) {
        return ret;
    }


    LOGV("queryEffects() numEffects: %d", numEffects);


    for (i = 0; i < numEffects; i++) {
        if (AudioEffect::queryEffect(i, &desc) != NO_ERROR) {
            goto queryEffects_failure;
        }
// +++++++++++++++++++++++++++++++AudioEffect::queryEffect+++++++++++++++++++++++++++++++++
status_t AudioEffect::queryEffect(uint32_t index, effect_descriptor_t *descriptor)
{
    const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
    if (af == 0) return PERMISSION_DENIED;
    return af->queryEffect(index, descriptor);
// +++++++++++++++++++++++++++++++AudioFlinger::queryEffect+++++++++++++++++++++++++++++++++
status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor)
{
    Mutex::Autolock _l(mLock);
    return EffectQueryEffect(index, descriptor);
// +++++++++++++++++++++++++++++EffectQueryEffect+++++++++++++++++++++++++++++++++++
int EffectQueryEffect(uint32_t index, effect_descriptor_t *pDescriptor)
{
    int ret = init();
    if (ret < 0) {
        return ret;
    }
    if (pDescriptor == NULL ||
        index >= gNumEffects) {
        return -EINVAL;
    }
    if (gCanQueryEffect == 0) {
        return -ENOSYS;
    }


    pthread_mutex_lock(&gLibLock);
    ret = -ENOENT;
    if (index < gCurEffectIdx) {
        resetEffectEnumeration();
// +++++++++++++++++++++++++++++++resetEffectEnumeration+++++++++++++++++++++++++++++++++
void resetEffectEnumeration()
{
    gCurLib = gLibraryList;
    gCurEffect = NULL;
    if (gCurLib) {
        gCurEffect = ((lib_entry_t *)gCurLib->object)->effects;
    }
    gCurEffectIdx = 0;
}
// -------------------------------resetEffectEnumeration---------------------------------
    }
    while (gCurLib) {
        if (gCurEffect) {
            if (index == gCurEffectIdx) {
                memcpy(pDescriptor, gCurEffect->object, sizeof(effect_descriptor_t));
                ret = 0;
                break;
            } else {
                gCurEffect = gCurEffect->next;
                gCurEffectIdx++;
            }
        } else {
            gCurLib = gCurLib->next;
            gCurEffect = ((lib_entry_t *)gCurLib->object)->effects;
        }
    }


#if (LOG_NDEBUG == 0)
    char str[256];
    dumpEffectDescriptor(pDescriptor, str, 256);
    LOGV("EffectQueryEffect() desc:%s", str);
#endif
    pthread_mutex_unlock(&gLibLock);
    return ret;
}
// ------------------------------EffectQueryEffect----------------------------------
}
// -------------------------------AudioFlinger::queryEffect---------------------------------
}
// -------------------------------AudioEffect::queryEffect---------------------------------


        AudioEffect::guidToString(&desc.type, str, EFFECT_STRING_LEN_MAX);
        jdescType = env->NewStringUTF(str);


        AudioEffect::guidToString(&desc.uuid, str, EFFECT_STRING_LEN_MAX);
        jdescUuid = env->NewStringUTF(str);


        if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
            jdescConnect = env->NewStringUTF("Auxiliary");
        } else {
            jdescConnect = env->NewStringUTF("Insert");
        }


        jdescName = env->NewStringUTF(desc.name);
        jdescImplementor = env->NewStringUTF(desc.implementor);


        jdesc = env->NewObject(fields.clazzDesc,
                               fields.midDescCstor,
                               jdescType,
                               jdescUuid,
                               jdescConnect,
                               jdescName,
                               jdescImplementor);
        env->DeleteLocalRef(jdescType);
        env->DeleteLocalRef(jdescUuid);
        env->DeleteLocalRef(jdescConnect);
        env->DeleteLocalRef(jdescName);
        env->DeleteLocalRef(jdescImplementor);
        if (jdesc == NULL) {
            LOGE("env->NewObject(fields.clazzDesc, fields.midDescCstor)");
            goto queryEffects_failure;
        }


        env->SetObjectArrayElement(ret, i, jdesc);
   }


    return ret;


queryEffects_failure:


    if (ret != NULL) {
        env->DeleteLocalRef(ret);
    }
    return NULL;


}
// ---------------------------android_media_AudioEffect_native_queryEffects-------------------------------------
    }
// ----------------------------queryEffects------------------------------------


        assertTrue("test0_0QueryEffects: number of effects < 4: "+desc.length, (desc.length >= 4));


        boolean hasEQ = false;
        boolean hasBassBoost = false;
        boolean hasVirtualizer = false;
        boolean hasEnvReverb = false;


        for (int i = 0; i < desc.length; i++) {
            if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_EQUALIZER)) {
                hasEQ = true;
            } if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_BASS_BOOST)) {
                hasBassBoost = true;
            } else if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_VIRTUALIZER)) {
                hasVirtualizer = true;
            }
            else if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_ENV_REVERB)) {
                hasEnvReverb = true;
            }
        }
        assertTrue("test0_0QueryEffects: equalizer not found", hasEQ);
        assertTrue("test0_0QueryEffects: bass boost not found", hasBassBoost);
        assertTrue("test0_0QueryEffects: virtualizer not found", hasVirtualizer);
        assertTrue("test0_0QueryEffects: environmental reverb not found", hasEnvReverb);
    }

###########################################################


&&&&&&&&&&&&&&&&&&&&&&&总结&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
queryEffects返回effect 列表中所有effect的描述。
通过函数EffectQueryNumberEffects可以取到effect列表中包含的effect的个数。
中EffectFactory的init函数中，会将build-in的effect lib添加到effect列表。
可以通过EffectLoadLibrary加载新的effect lib。
也可以通过EffectUnloadLibrary卸载已加载的effect lib。
可以通过函数EffectCreate创建effect。
也可以通过函数EffectRelease删除effect。
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&