/*
 * RkAiqHandleInt.cpp
 *
 *  Copyright (c) 2019 Rockchip Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include "RkAiqHandleInt.h"
#include "RkAiqCore.h"
#include "aiq_core/RkAiqSharedDataManager.h"
#include "smart_buffer_priv.h"
#include "media_buffer/media_buffer_pool.h"

namespace RkCam {

XCamReturn RkAiqHandleIntCom::configInparamsCom(RkAiqAlgoCom* com, int type)
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqAlgoComInt* rk_com = NULL;

#define GET_RK_COM(algo) \
    { \
        if (type == RKAIQ_CONFIG_COM_PREPARE) \
            rk_com = &(((RkAiqAlgoConfig##algo##Int*)com)->rk_com); \
        else if (type == RKAIQ_CONFIG_COM_PRE) \
            rk_com = &(((RkAiqAlgoPre##algo##Int*)com)->rk_com); \
        else if (type == RKAIQ_CONFIG_COM_PROC) \
            rk_com = &(((RkAiqAlgoProc##algo##Int*)com)->rk_com); \
        else if (type == RKAIQ_CONFIG_COM_POST) \
            rk_com = &(((RkAiqAlgoPost##algo##Int*)com)->rk_com); \
    } \

    switch (mDes->type) {
    case RK_AIQ_ALGO_TYPE_AE:
        GET_RK_COM(Ae);
        break;
    case RK_AIQ_ALGO_TYPE_AWB:
        GET_RK_COM(Awb);
        break;
    case RK_AIQ_ALGO_TYPE_AF:
        GET_RK_COM(Af);
        break;
    case RK_AIQ_ALGO_TYPE_ABLC:
        GET_RK_COM(Ablc);
        break;
    case RK_AIQ_ALGO_TYPE_ADPCC:
        GET_RK_COM(Adpcc);
        break;
    case RK_AIQ_ALGO_TYPE_AMERGE:
        GET_RK_COM(Amerge);
        break;
    case RK_AIQ_ALGO_TYPE_ATMO:
        GET_RK_COM(Atmo);
        break;
    case RK_AIQ_ALGO_TYPE_ANR:
        GET_RK_COM(Anr);
        break;
    case RK_AIQ_ALGO_TYPE_ALSC:
        GET_RK_COM(Alsc);
        break;
    case RK_AIQ_ALGO_TYPE_AGIC:
        GET_RK_COM(Agic);
        break;
    case RK_AIQ_ALGO_TYPE_ADEBAYER:
        GET_RK_COM(Adebayer);
        break;
    case RK_AIQ_ALGO_TYPE_ACCM:
        GET_RK_COM(Accm);
        break;
    case RK_AIQ_ALGO_TYPE_AGAMMA:
        GET_RK_COM(Agamma);
        break;
    case RK_AIQ_ALGO_TYPE_ADEGAMMA:
        GET_RK_COM(Adegamma);
        break;
    case RK_AIQ_ALGO_TYPE_AWDR:
        GET_RK_COM(Awdr);
        break;
    case RK_AIQ_ALGO_TYPE_ADHAZ:
        GET_RK_COM(Adhaz);
        break;
    case RK_AIQ_ALGO_TYPE_A3DLUT:
        GET_RK_COM(A3dlut);
        break;
    case RK_AIQ_ALGO_TYPE_ALDCH:
        GET_RK_COM(Aldch);
        break;
    case RK_AIQ_ALGO_TYPE_AR2Y:
        GET_RK_COM(Ar2y);
        break;
    case RK_AIQ_ALGO_TYPE_ACP:
        GET_RK_COM(Acp);
        break;
    case RK_AIQ_ALGO_TYPE_AIE:
        GET_RK_COM(Aie);
        break;
    case RK_AIQ_ALGO_TYPE_ASHARP:
        GET_RK_COM(Asharp);
        break;
    case RK_AIQ_ALGO_TYPE_AORB:
        GET_RK_COM(Aorb);
        break;
    case RK_AIQ_ALGO_TYPE_AFEC:
        GET_RK_COM(Afec);
        break;
    case RK_AIQ_ALGO_TYPE_ACGC:
        GET_RK_COM(Acgc);
        break;
    case RK_AIQ_ALGO_TYPE_ASD:
        GET_RK_COM(Asd);
        break;
    case RK_AIQ_ALGO_TYPE_ADRC:
        GET_RK_COM(Adrc);
        break;
    case RK_AIQ_ALGO_TYPE_AYNR:
        GET_RK_COM(Aynr);
        break;
    case RK_AIQ_ALGO_TYPE_ACNR:
        GET_RK_COM(Acnr);
        break;
    case RK_AIQ_ALGO_TYPE_ARAWNR:
        GET_RK_COM(Arawnr);
        break;
    case RK_AIQ_ALGO_TYPE_AEIS:
        GET_RK_COM(Aeis);
        break;
    case RK_AIQ_ALGO_TYPE_AMD:
        GET_RK_COM(Amd);
        break;
    case RK_AIQ_ALGO_TYPE_AMFNR:
        GET_RK_COM(Amfnr);
        break;
    case RK_AIQ_ALGO_TYPE_AGAIN:
        GET_RK_COM(Again);
        break;
    default:
        LOGE_ANALYZER("wrong algo type !");
    }

    if (!rk_com)
        goto out;

    xcam_mem_clear(*rk_com);

    if (type == RkAiqHandle::RKAIQ_CONFIG_COM_PREPARE) {
        rk_com->u.prepare.calib = (CamCalibDbContext_t*)(sharedCom->calib);
        rk_com->u.prepare.calibv2 = (CamCalibDbV2Context_t*)(sharedCom->calibv2);
    } else {
        rk_com->u.proc.pre_res_comb = &shared->preResComb;
        rk_com->u.proc.proc_res_comb = &shared->procResComb;
        rk_com->u.proc.post_res_comb = &shared->postResComb;
        rk_com->u.proc.iso = sharedCom->iso;
        rk_com->u.proc.fill_light_on = sharedCom->fill_light_on;
        rk_com->u.proc.gray_mode = sharedCom->gray_mode;
        rk_com->u.proc.is_bw_sensor = sharedCom->is_bw_sensor;
        rk_com->u.proc.preExp = &shared->preExp;
        rk_com->u.proc.curExp = &shared->curExp;
        rk_com->u.proc.res_comb = &shared->res_comb;
    }

    EXIT_ANALYZER_FUNCTION();
out:
    return RkAiqHandle::configInparamsCom(com, type);
}

void
RkAiqHandleIntCom::waitSignal()
{
    if (mAiqCore->isRunningState()) {
        mUpdateCond.timedwait(mCfgMutex, 100000);
    } else {
        updateConfig(false);
    }
}

void
RkAiqHandleIntCom::sendSignal()
{
    if (mAiqCore->isRunningState())
        mUpdateCond.signal();
}

void
RkAiqAeHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAeHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAeInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAeInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAeInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAeInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAeInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAeInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAeInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAeHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    if (needSync)
        mCfgMutex.lock();
    // if something changed, api will modify aecCfg in mAlgoCtx
    if (updateExpSwAttr) {
        mCurExpSwAttr = mNewExpSwAttr;
        updateExpSwAttr = false;
        updateAttr |= UPDATE_EXPSWATTR;

        Uapi_ExpSwAttr_t ExpSwAttrV1 = mCurExpSwAttr;
        rk_aiq_uapi_ae_convExpSwAttr_v1Tov2(&ExpSwAttrV1, &mCurExpSwAttrV2);

        rk_aiq_uapi_ae_setExpSwAttr(mAlgoCtx, &mCurExpSwAttrV2, false);
        sendSignal();
    }

    if (updateLinExpAttr) {
        mCurLinExpAttr = mNewLinExpAttr;
        updateLinExpAttr = false;
        updateAttr |= UPDATE_LINEXPATTR;

        Uapi_LinExpAttr_t LinExpAttrV1 = mCurLinExpAttr;
        rk_aiq_uapi_ae_convLinExpAttr_v1Tov2(&LinExpAttrV1, &mCurLinExpAttrV2);

        rk_aiq_uapi_ae_setLinExpAttr(mAlgoCtx, &mCurLinExpAttrV2, false);
        sendSignal();
    }

    if (updateHdrExpAttr) {
        mCurHdrExpAttr = mNewHdrExpAttr;
        updateHdrExpAttr = false;
        updateAttr |= UPDATE_HDREXPATTR;

        Uapi_HdrExpAttr_t HdrExpAttrV1 = mCurHdrExpAttr;
        rk_aiq_uapi_ae_convHdrExpAttr_v1Tov2(&HdrExpAttrV1, &mCurHdrExpAttrV2);

        rk_aiq_uapi_ae_setHdrExpAttr(mAlgoCtx, &mCurHdrExpAttrV2, false);
        sendSignal();
    }

    // TODO: update v2

    if (updateExpSwAttrV2) {
        mCurExpSwAttrV2 = mNewExpSwAttrV2;
        updateExpSwAttrV2 = false;
        updateAttr |= UPDATE_EXPSWATTR;

        rk_aiq_uapi_ae_setExpSwAttr(mAlgoCtx, &mCurExpSwAttrV2, false);
        sendSignal();
    }

    if (updateLinExpAttrV2) {
        mCurLinExpAttrV2 = mNewLinExpAttrV2;
        updateLinExpAttrV2 = false;
        updateAttr |= UPDATE_LINEXPATTR;

        rk_aiq_uapi_ae_setLinExpAttr(mAlgoCtx, &mCurLinExpAttrV2, false);
        sendSignal();
    }

    if (updateHdrExpAttrV2) {
        mCurHdrExpAttrV2 = mNewHdrExpAttrV2;
        updateHdrExpAttrV2 = false;
        updateAttr |= UPDATE_HDREXPATTR;

        rk_aiq_uapi_ae_setHdrExpAttr(mAlgoCtx, &mCurHdrExpAttrV2, false);
        sendSignal();
    }

    if (updateLinAeRouteAttr) {
        mCurLinAeRouteAttr = mNewLinAeRouteAttr;
        updateLinAeRouteAttr = false;
        updateAttr |= UPDATE_LINAEROUTEATTR;
        rk_aiq_uapi_ae_setLinAeRouteAttr(mAlgoCtx, &mCurLinAeRouteAttr, false);
        sendSignal();
    }
    if (updateHdrAeRouteAttr) {
        mCurHdrAeRouteAttr = mNewHdrAeRouteAttr;
        updateHdrAeRouteAttr = false;
        updateAttr |= UPDATE_HDRAEROUTEATTR;
        rk_aiq_uapi_ae_setHdrAeRouteAttr(mAlgoCtx, &mCurHdrAeRouteAttr, false);
        sendSignal();
    }
    if (updateIrisAttr) {
        mCurIrisAttr = mNewIrisAttr;
        updateIrisAttr = false;
        updateAttr |= UPDATE_IRISATTR;
        rk_aiq_uapi_ae_setIrisAttr(mAlgoCtx, &mCurIrisAttr, false);
        sendSignal();
    }
    if (updateSyncTestAttr) {
        mCurAecSyncTestAttr = mNewAecSyncTestAttr;
        updateSyncTestAttr = false;
        updateAttr |= UPDATE_SYNCTESTATTR;
        rk_aiq_uapi_ae_setSyncTest(mAlgoCtx, &mCurAecSyncTestAttr, false);
        sendSignal();
    }
    if (updateExpWinAttr) {
        mCurExpWinAttr = mNewExpWinAttr;
        updateExpWinAttr = false;
        updateAttr |= UPDATE_EXPWINATTR;
        rk_aiq_uapi_ae_setExpWinAttr(mAlgoCtx, &mCurExpWinAttr, false);
        sendSignal();
    }

    // once any params are changed, run reconfig to convert aecCfg to paectx
    AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
    AeConfig_t pAecCfg = pAeInstConfig->aecCfg;
    pAecCfg->IsReconfig |= updateAttr;
    updateAttr = 0;
    if (needSync)
        mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAeHandleInt::setExpSwAttr(Uapi_ExpSwAttr_t ExpSwAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurExpSwAttr, &ExpSwAttr, sizeof(Uapi_ExpSwAttr_t))) {
        mNewExpSwAttr = ExpSwAttr;
        updateExpSwAttr = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getExpSwAttr(Uapi_ExpSwAttr_t* pExpSwAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    Uapi_ExpSwAttrV2_t ExpSwAttrV2;
    memset(&ExpSwAttrV2, 0x00, sizeof(Uapi_ExpSwAttrV2_t));
    rk_aiq_uapi_ae_getExpSwAttr(mAlgoCtx, &ExpSwAttrV2);
    rk_aiq_uapi_ae_convExpSwAttr_v2Tov1(&ExpSwAttrV2, pExpSwAttr);

    mCurExpSwAttrV2 = ExpSwAttrV2;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::setExpSwAttr(Uapi_ExpSwAttrV2_t ExpSwAttrV2)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurExpSwAttrV2, &ExpSwAttrV2, sizeof(Uapi_ExpSwAttrV2_t))) {
        mNewExpSwAttrV2 = ExpSwAttrV2;
        updateExpSwAttrV2 = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getExpSwAttr(Uapi_ExpSwAttrV2_t* pExpSwAttrV2)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ae_getExpSwAttr(mAlgoCtx, pExpSwAttrV2);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAeHandleInt::setLinExpAttr(Uapi_LinExpAttr_t LinExpAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurLinExpAttr, &LinExpAttr, sizeof(Uapi_LinExpAttr_t))) {
        mNewLinExpAttr = LinExpAttr;
        updateLinExpAttr = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getLinExpAttr(Uapi_LinExpAttr_t* pLinExpAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    Uapi_LinExpAttrV2_t LinExpAttrV2;
    memset(&LinExpAttrV2, 0x00, sizeof(Uapi_LinExpAttrV2_t));

    rk_aiq_uapi_ae_getLinExpAttr(mAlgoCtx, &LinExpAttrV2);
    rk_aiq_uapi_ae_convLinExpAttr_v2Tov1(&LinExpAttrV2, pLinExpAttr);

    mCurLinExpAttrV2 = LinExpAttrV2;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::setLinExpAttr(Uapi_LinExpAttrV2_t LinExpAttrV2)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurLinExpAttrV2, &LinExpAttrV2, sizeof(Uapi_LinExpAttrV2_t))) {
        mNewLinExpAttrV2 = LinExpAttrV2;
        updateLinExpAttrV2 = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getLinExpAttr(Uapi_LinExpAttrV2_t* pLinExpAttrV2)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ae_getLinExpAttr(mAlgoCtx, pLinExpAttrV2);

    EXIT_ANALYZER_FUNCTION();
    return ret;

}

XCamReturn
RkAiqAeHandleInt::setHdrExpAttr(Uapi_HdrExpAttr_t HdrExpAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurHdrExpAttr, &HdrExpAttr, sizeof(Uapi_HdrExpAttr_t))) {
        mNewHdrExpAttr = HdrExpAttr;
        updateHdrExpAttr = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getHdrExpAttr (Uapi_HdrExpAttr_t* pHdrExpAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    Uapi_HdrExpAttrV2_t HdrExpAttrV2;
    memset(&HdrExpAttrV2, 0x00, sizeof(Uapi_HdrExpAttrV2_t));

    rk_aiq_uapi_ae_getHdrExpAttr(mAlgoCtx, &HdrExpAttrV2);
    rk_aiq_uapi_ae_convHdrExpAttr_v2Tov1(&HdrExpAttrV2, pHdrExpAttr);

    mCurHdrExpAttrV2 = HdrExpAttrV2;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::setHdrExpAttr(Uapi_HdrExpAttrV2_t HdrExpAttrV2)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurHdrExpAttrV2, &HdrExpAttrV2, sizeof(Uapi_HdrExpAttrV2_t))) {
        mNewHdrExpAttrV2 = HdrExpAttrV2;
        updateHdrExpAttrV2 = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getHdrExpAttr (Uapi_HdrExpAttrV2_t* pHdrExpAttrV2)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ae_getHdrExpAttr(mAlgoCtx, pHdrExpAttrV2);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAeHandleInt::setLinAeRouteAttr(Uapi_LinAeRouteAttr_t LinAeRouteAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed

    if (0 != memcmp(&mCurLinAeRouteAttr, &LinAeRouteAttr, sizeof(Uapi_LinAeRouteAttr_t))) {
        mNewLinAeRouteAttr = LinAeRouteAttr;
        updateLinAeRouteAttr = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getLinAeRouteAttr(Uapi_LinAeRouteAttr_t* pLinAeRouteAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ae_getLinAeRouteAttr(mAlgoCtx, pLinAeRouteAttr);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::setHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t HdrAeRouteAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurHdrAeRouteAttr, &HdrAeRouteAttr, sizeof(Uapi_HdrAeRouteAttr_t))) {
        mNewHdrAeRouteAttr = HdrAeRouteAttr;
        updateHdrAeRouteAttr = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t* pHdrAeRouteAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ae_getHdrAeRouteAttr(mAlgoCtx, pHdrAeRouteAttr);

    EXIT_ANALYZER_FUNCTION();
    return ret;

}

XCamReturn
RkAiqAeHandleInt::setIrisAttr(Uapi_IrisAttrV2_t IrisAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed

    if (0 != memcmp(&mCurIrisAttr, &IrisAttr, sizeof(Uapi_IrisAttrV2_t))) {
        mNewIrisAttr = IrisAttr;
        updateIrisAttr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getIrisAttr(Uapi_IrisAttrV2_t * pIrisAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ae_getIrisAttr(mAlgoCtx, pIrisAttr);

    EXIT_ANALYZER_FUNCTION();
    return ret;

}

XCamReturn
RkAiqAeHandleInt::setSyncTestAttr(Uapi_AecSyncTest_t SyncTestAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed

    if (0 != memcmp(&mCurAecSyncTestAttr, &SyncTestAttr, sizeof(Uapi_AecSyncTest_t))) {
        mNewAecSyncTestAttr = SyncTestAttr;
        updateSyncTestAttr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getSyncTestAttr(Uapi_AecSyncTest_t * pSyncTestAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ae_getSyncTest(mAlgoCtx, pSyncTestAttr);

    EXIT_ANALYZER_FUNCTION();
    return ret;

}

XCamReturn
RkAiqAeHandleInt::setExpWinAttr(Uapi_ExpWin_t ExpWinAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed

    if (0 != memcmp(&mCurExpWinAttr, &ExpWinAttr, sizeof(Uapi_ExpWin_t))) {
        mNewExpWinAttr = ExpWinAttr;
        updateExpWinAttr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::getExpWinAttr(Uapi_ExpWin_t * pExpWinAttr)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ae_getExpWinAttr(mAlgoCtx, pExpWinAttr);

    EXIT_ANALYZER_FUNCTION();
    return ret;

}
XCamReturn
RkAiqAeHandleInt::queryExpInfo(Uapi_ExpQueryInfo_t* pExpQueryInfo)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ae_queryExpInfo(mAlgoCtx, pExpQueryInfo);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAeHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAeHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "ae handle prepare failed");

    RkAiqAlgoConfigAeInt* ae_config_int = (RkAiqAlgoConfigAeInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    /*****************AecConfig pic-info params*****************/
    ae_config_int->RawWidth = sharedCom->snsDes.isp_acq_width;
    ae_config_int->RawHeight = sharedCom->snsDes.isp_acq_height;
    ae_config_int->nr_switch = sharedCom->snsDes.nr_switch;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "ae algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAeHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAeInt* ae_pre_int = (RkAiqAlgoPreAeInt*)mPreInParam;
    RkAiqAlgoPreResAeInt* ae_pre_res_int = nullptr;
    if (mAiqCore->mAlogsComSharedParams.init) {
        ae_pre_res_int = (RkAiqAlgoPreResAeInt*)mPreOutParam;
    } else {
        mPreResShared = new RkAiqAlgoPreResAeIntShared();
        if (!mPreResShared.ptr()) {
            LOGE("new ae mPreOutParam failed, bypass!");
            return XCAM_RETURN_BYPASS;
        }
        ae_pre_res_int = &mPreResShared->result;
    }

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;
    RkAiqPreResComb* comb = &shared->preResComb;

    ret = RkAiqAeHandle::preProcess();
    if (ret) {
        comb->ae_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ae handle preProcess failed");
    }

    comb->ae_pre_res = NULL;

    ae_pre_int->aecStatsBuf = shared->aecStatsBuf;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    if (mAiqCore->mAlogsComSharedParams.init)
        ret = des->pre_process(mPreInParam, mPreOutParam);
    else
        ret = des->pre_process(mPreInParam, (RkAiqAlgoResCom*)ae_pre_res_int);
    RKAIQCORE_CHECK_RET(ret, "ae algo pre_process failed");

    // set result to mAiqCore
    comb->ae_pre_res = (RkAiqAlgoPreResAe*)ae_pre_res_int;

    if (!mAiqCore->mAlogsComSharedParams.init) {
        mPreResShared->set_sequence(shared->frameId);
        SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AE_PRE_RES_OK,
                shared->frameId, mPreResShared);
        mAiqCore->post_message(msg);
    }

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAeHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAeInt* ae_proc_int = (RkAiqAlgoProcAeInt*)mProcInParam;
    RkAiqAlgoProcResAeInt* ae_proc_res_int = nullptr;
    if (mAiqCore->mAlogsComSharedParams.init) {
        ae_proc_res_int = (RkAiqAlgoProcResAeInt*)mProcOutParam;
    } else {
        mProcResShared = new RkAiqAlgoProcResAeIntShared();
        if (!mProcResShared.ptr()) {
            LOGE("new ae mProcOutParam failed, bypass!");
            return XCAM_RETURN_BYPASS;
        }
        ae_proc_res_int = &mProcResShared->result;
        // mProcOutParam = (RkAiqAlgoResCom*)ae_proc_res_int;
    }

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAeHandle::processing();
    if (ret) {
        comb->ae_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ae handle processing failed");
    }

    comb->ae_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    if (mAiqCore->mAlogsComSharedParams.init)
        ret = des->processing(mProcInParam, mProcOutParam);
    else
        ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)ae_proc_res_int);
    RKAIQCORE_CHECK_RET(ret, "ae algo processing failed");

    comb->ae_proc_res = (RkAiqAlgoProcResAe*)ae_proc_res_int;

    if (mAiqCore->mAlogsComSharedParams.init) {
        RkAiqCore::RkAiqAlgosGroupShared_t* measGroupshared = nullptr;
        if (mAiqCore->getGroupSharedParams(RK_AIQ_CORE_ANALYZE_MEAS, measGroupshared) != XCAM_RETURN_NO_ERROR)
            LOGW("get the shared of meas failed");
        if (measGroupshared) {
            measGroupshared->frameId = shared->frameId;
            measGroupshared->preResComb.ae_pre_res = shared->preResComb.ae_pre_res;
            measGroupshared->procResComb.ae_proc_res = shared->procResComb.ae_proc_res;
            measGroupshared->postResComb.ae_post_res = shared->postResComb.ae_post_res;
        }
    } else {
        mProcResShared->set_sequence(shared->frameId);
        SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AE_PROC_RES_OK,
                shared->frameId, mProcResShared);
        mAiqCore->post_message(msg);
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAeHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAeInt* ae_post_int = (RkAiqAlgoPostAeInt*)mPostInParam;
    RkAiqAlgoPostResAeInt* ae_post_res_int = (RkAiqAlgoPostResAeInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAeHandle::postProcess();
    if (ret) {
        comb->ae_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ae handle postProcess failed");
        return ret;
    }

    comb->ae_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "ae algo post_process failed");
    // set result to mAiqCore
    comb->ae_post_res = (RkAiqAlgoPostResAe*)ae_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAwbHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAwbHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAwbInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAwbInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAwbInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAwbInt());
    // mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAwbInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAwbInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAwbInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAwbHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_awb_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }
    if (updateWbV20Attr) {
        mCurWbV20Attr = mNewWbV20Attr;
        updateWbV20Attr = false;
        rk_aiq_uapiV2_awbV20_SetAttrib(mAlgoCtx, mCurWbV20Attr, false);
        sendSignal();
    }
    if (updateWbOpModeAttr) {
        mCurWbOpModeAttr = mNewWbOpModeAttr;
        updateWbOpModeAttr = false;
        rk_aiq_uapiV2_awb_SetMwbMode(mAlgoCtx, mCurWbOpModeAttr, false);
        sendSignal();
    }
    if (updateWbMwbAttr) {
        mCurWbMwbAttr = mNewWbMwbAttr;
        updateWbMwbAttr = false;
        rk_aiq_uapiV2_awb_SetMwbAttrib(mAlgoCtx, mCurWbMwbAttr, false);
        sendSignal();
    }
    if (updateWbAwbAttr) {
        mCurWbAwbAttr = mNewWbAwbAttr;
        updateWbAwbAttr = false;
        rk_aiq_uapiV2_awbV20_SetAwbAttrib(mAlgoCtx, mCurWbAwbAttr, false);
        sendSignal();
    }
    if (updateWbAwbWbGainAdjustAttr) {
        mCurWbAwbWbGainAdjustAttr = mNewWbAwbWbGainAdjustAttr;
        updateWbAwbWbGainAdjustAttr = false;
        rk_aiq_uapiV2_awb_SetAwbGainAdjust(mAlgoCtx, mCurWbAwbWbGainAdjustAttr, false);
        sendSignal();
    }
    if (updateWbAwbWbGainOffsetAttr) {
        mCurWbAwbWbGainOffsetAttr = mNewWbAwbWbGainOffsetAttr;
        updateWbAwbWbGainOffsetAttr = false;
        rk_aiq_uapiV2_awb_SetAwbGainOffset(mAlgoCtx, mCurWbAwbWbGainOffsetAttr, false);
        sendSignal();
    }
    if (updateWbAwbMultiWindowAttr) {
        mCurWbAwbMultiWindowAttr = mNewWbAwbMultiWindowAttr;
        updateWbAwbMultiWindowAttr = false;
        rk_aiq_uapiV2_awb_SetAwbMultiwindow(mAlgoCtx, mCurWbAwbMultiWindowAttr, false);
        sendSignal();
    }
    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::setAttrib(rk_aiq_wb_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_wb_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::getAttrib(rk_aiq_wb_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_awb_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::getCct(rk_aiq_wb_cct_t *cct)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awb_GetCCT(mAlgoCtx, cct);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::queryWBInfo(rk_aiq_wb_querry_info_t *wb_querry_info )
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awb_QueryWBInfo(mAlgoCtx, wb_querry_info);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::lock()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awb_Lock(mAlgoCtx);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::unlock()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awb_Unlock(mAlgoCtx);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAwbHandleInt::setWbV20Attrib(rk_aiq_uapiV2_wbV20_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurWbV20Attr, &att, sizeof(rk_aiq_uapiV2_wbV20_attrib_t))) {
        mNewWbV20Attr = att;
        updateWbV20Attr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::getWbV20Attrib(rk_aiq_uapiV2_wbV20_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awbV20_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::setWbOpModeAttrib(rk_aiq_wb_op_mode_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurWbOpModeAttr, &att, sizeof(rk_aiq_wb_op_mode_t))) {
        mNewWbOpModeAttr = att;
        updateWbOpModeAttr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::getWbOpModeAttrib(rk_aiq_wb_op_mode_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awb_GetMwbMode(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::setMwbAttrib(rk_aiq_wb_mwb_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurWbMwbAttr, &att, sizeof(rk_aiq_wb_mwb_attrib_t))) {
        mNewWbMwbAttr = att;
        updateWbMwbAttr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::getMwbAttrib(rk_aiq_wb_mwb_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awb_GetMwbAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAwbHandleInt::setAwbV20Attrib(rk_aiq_uapiV2_wbV20_awb_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurWbAwbAttr, &att, sizeof(rk_aiq_uapiV2_wbV20_awb_attrib_t))) {
        mNewWbAwbAttr = att;
        updateWbAwbAttr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::getAwbV20Attrib(rk_aiq_uapiV2_wbV20_awb_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awbV20_GetAwbAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::setWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurWbAwbWbGainAdjustAttr, &att, sizeof(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t))) {
        mNewWbAwbWbGainAdjustAttr = att;
        updateWbAwbWbGainAdjustAttr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::getWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awb_GetAwbGainAdjust(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAwbHandleInt::setWbAwbWbGainOffsetAttrib(CalibDbV2_Awb_gain_offset_cfg_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurWbAwbWbGainOffsetAttr, &att, sizeof(CalibDbV2_Awb_gain_offset_cfg_t))) {
        mNewWbAwbWbGainOffsetAttr = att;
        updateWbAwbWbGainOffsetAttr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::getWbAwbWbGainOffsetAttrib(CalibDbV2_Awb_gain_offset_cfg_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awb_GetAwbGainOffset(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::setWbAwbMultiWindowAttrib(CalibDbV2_Awb_Mul_Win_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurWbAwbMultiWindowAttr, &att, sizeof(CalibDbV2_Awb_Mul_Win_t))) {
        mNewWbAwbMultiWindowAttr = att;
        updateWbAwbMultiWindowAttr = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::getWbAwbMultiWindowAttrib(CalibDbV2_Awb_Mul_Win_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapiV2_awb_GetAwbMultiwindow(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAwbHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "awb handle prepare failed");

    RkAiqAlgoConfigAwbInt* awb_config_int = (RkAiqAlgoConfigAwbInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    // TODO
    //awb_config_int->rawBit;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "awb algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAwbInt* awb_pre_int = (RkAiqAlgoPreAwbInt*)mPreInParam;
    RkAiqAlgoPreResAwbInt* awb_pre_res_int = (RkAiqAlgoPreResAwbInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAwbHandle::preProcess();
    if (ret) {
        comb->awb_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "awb handle preProcess failed");
    }
    comb->awb_pre_res = NULL;
    int module_hw_version = sharedCom->ctxCfigs[RK_AIQ_ALGO_TYPE_AWB].cfg_com.module_hw_version;
#ifdef RK_SIMULATOR_HW
    if(module_hw_version == AWB_HARDWARE_V200) {
        awb_pre_int->awb_hw0_statis = ispStats->awb_stats;
        awb_pre_int->awb_cfg_effect_v200 = ispStats->awb_cfg_effect_v200;
    } else {
        awb_pre_int->awb_hw1_statis = ispStats->awb_stats_v201;
        awb_pre_int->awb_cfg_effect_v201 = ispStats->awb_cfg_effect_v201;
    }
#else
    awb_pre_int->awbStatsBuf = shared->awbStatsBuf;
#endif
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "awb algo pre_process failed");
    // set result to mAiqCore
    comb->awb_pre_res = (RkAiqAlgoPreResAwb*)awb_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAwbInt* awb_proc_int = (RkAiqAlgoProcAwbInt*)mProcInParam;
#if 0
    RkAiqAlgoProcResAwbInt* awb_proc_res_int = (RkAiqAlgoProcResAwbInt*)mProcOutParam;
#else
    mProcResShared = new RkAiqAlgoProcResAwbIntShared();
    if (!mProcResShared.ptr()) {
        LOGE("new awb mProcOutParam failed, bypass!");
        return XCAM_RETURN_BYPASS;
    }
    RkAiqAlgoProcResAwbInt* awb_proc_res_int = &mProcResShared->result;
    // mProcOutParam = (RkAiqAlgoResCom*)awb_proc_res_int;
#endif
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAwbHandle::processing();
    if (ret) {
        comb->awb_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "awb handle processing failed");
    }

    comb->awb_proc_res = NULL;


    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
#if 0
    ret = des->processing(mProcInParam, mProcOutParam);
#else
    ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)awb_proc_res_int);
#endif
    RKAIQCORE_CHECK_RET(ret, "awb algo processing failed");
    // set result to mAiqCore
    comb->awb_proc_res = (RkAiqAlgoProcResAwb*)awb_proc_res_int;

    mProcResShared->set_sequence(shared->frameId);
    SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AWB_PROC_RES_OK,
            shared->frameId, mProcResShared);
    mAiqCore->post_message(msg);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwbHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAwbInt* awb_post_int = (RkAiqAlgoPostAwbInt*)mPostInParam;
    RkAiqAlgoPostResAwbInt* awb_post_res_int = (RkAiqAlgoPostResAwbInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAwbHandle::postProcess();
    if (ret) {
        comb->awb_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "awb handle postProcess failed");
        return ret;
    }

    comb->awb_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "awb algo post_process failed");
    // set result to mAiqCore
    comb->awb_post_res = (RkAiqAlgoPostResAwb*)awb_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAfHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAfHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAfInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAfInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAfInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAfInt());
#if 0
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAfInt());
#endif
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAfInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAfInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAfHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support) {
        if (needSync)
            mCfgMutex.lock();
        // if something changed
        if (updateAtt) {
            rk_aiq_uapi_af_SetAttrib(mAlgoCtx, mNewAtt, false);
            isUpdateAttDone = true;
        }
        if (needSync)
            mCfgMutex.unlock();
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::setAttrib(rk_aiq_af_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support) {
        mCfgMutex.lock();
        //TODO
        // check if there is different between att & mCurAtt
        // if something changed, set att to mNewAtt, and
        // the new params will be effective later when updateConfig
        // called by RkAiqCore

        // if something changed
        if ((0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_af_attrib_t))) ||
            (mCurAtt.AfMode == RKAIQ_AF_MODE_AUTO)) {
            mNewAtt = *att;
            updateAtt = true;
            isUpdateAttDone = false;
            waitSignal();
        }

        mCfgMutex.unlock();
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::getAttrib(rk_aiq_af_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_af_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::lock()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support)
        rk_aiq_uapi_af_Lock(mAlgoCtx);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::unlock()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support)
        rk_aiq_uapi_af_Unlock(mAlgoCtx);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::Oneshot()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support)
        rk_aiq_uapi_af_Oneshot(mAlgoCtx);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::ManualTriger()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support)
        rk_aiq_uapi_af_ManualTriger(mAlgoCtx);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::Tracking()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support)
        rk_aiq_uapi_af_Tracking(mAlgoCtx);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::setZoomPos(int zoom_pos)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support)
        rk_aiq_uapi_af_setZoomPos(mAlgoCtx, zoom_pos);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::GetSearchPath(rk_aiq_af_sec_path_t* path)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support)
        rk_aiq_uapi_af_getSearchPath(mAlgoCtx, path);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::GetSearchResult(rk_aiq_af_result_t* result)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (sharedCom->snsDes.lens_des.focus_support)
        rk_aiq_uapi_af_getSearchResult(mAlgoCtx, result);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAfHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "af handle prepare failed");

    RkAiqAlgoConfigAfInt* af_config_int = (RkAiqAlgoConfigAfInt*)mConfig;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    af_config_int->af_config_com.af_mode = 6;
    af_config_int->af_config_com.win_h_offs = 0;
    af_config_int->af_config_com.win_v_offs = 0;
    af_config_int->af_config_com.win_h_size = 0;
    af_config_int->af_config_com.win_v_size = 0;
    af_config_int->af_config_com.lens_des = sharedCom->snsDes.lens_des;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "af algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAfHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAfInt* af_pre_int = (RkAiqAlgoPreAfInt*)mPreInParam;
    RkAiqAlgoPreResAfInt* af_pre_res_int = (RkAiqAlgoPreResAfInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAfHandle::preProcess();
    if (ret) {
        comb->af_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "af handle preProcess failed");
    }

    comb->af_pre_res = NULL;
    af_pre_int->af_stats = &ispStats->af_stats;
    af_pre_int->aec_stats = &ispStats->aec_stats;

    af_pre_int->xcam_af_stats = shared->afStatsBuf;
    af_pre_int->xcam_aec_stats = shared->aecStatsBuf;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "af algo pre_process failed");
    // set result to mAiqCore
    comb->af_pre_res = (RkAiqAlgoPreResAf*)af_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAfHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();


    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAfInt* af_proc_int = (RkAiqAlgoProcAfInt*)mProcInParam;
#if 0
    RkAiqAlgoProcResAfInt* af_proc_res_int = (RkAiqAlgoProcResAfInt*)mProcOutParam;
#else
    mProcResShared = new RkAiqAlgoProcResAfIntShared();
    if (!mProcResShared.ptr()) {
        LOGE("new af mProcOutParam failed, bypass!");
        return XCAM_RETURN_BYPASS;
    }
    RkAiqAlgoProcResAfInt* af_proc_res_int = &mProcResShared->result;
    // mProcOutParam = (RkAiqAlgoResCom*)af_proc_res_int;
#endif
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAfHandle::processing();
    if (ret) {
        comb->af_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "af handle processing failed");
    }

    comb->af_proc_res = NULL;

    af_proc_int->af_proc_com.xcam_af_stats = shared->afStatsBuf;
    af_proc_int->af_proc_com.xcam_aec_stats = shared->aecStatsBuf;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
#if 0
    ret = des->processing(mProcInParam, mProcOutParam);
#else
    ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)af_proc_res_int);
#endif
    RKAIQCORE_CHECK_RET(ret, "af algo processing failed");

    comb->af_proc_res = (RkAiqAlgoProcResAf*)af_proc_res_int;

#if 1
    af_proc_res_int->id = shared->frameId;
    SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AF_PROC_RES_OK,
            af_proc_res_int->id, mProcResShared);
    mAiqCore->post_message(msg);
#endif

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAfInt* af_post_int = (RkAiqAlgoPostAfInt*)mPostInParam;
    RkAiqAlgoPostResAfInt* af_post_res_int = (RkAiqAlgoPostResAfInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAfHandle::postProcess();
    if (ret) {
        comb->af_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "af handle postProcess failed");
        return ret;
    }

    comb->af_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "af algo post_process failed");
    // set result to mAiqCore
    comb->af_post_res = (RkAiqAlgoPostResAf*)af_post_res_int ;

    if (updateAtt && isUpdateAttDone) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        isUpdateAttDone = false;
        sendSignal();
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAnrHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAnrHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAnrInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAnrInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAnrInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAnrInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAnrInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAnrInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAnrInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAnrHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_anr_SetAttrib(mAlgoCtx, &mCurAtt, false);
        sendSignal();
    }

    if(UpdateIQpara) {
        mCurIQpara = mNewIQpara;
        UpdateIQpara = false;
        rk_aiq_uapi_anr_SetIQPara(mAlgoCtx, &mCurIQpara, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::setAttrib(rk_aiq_nr_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_nr_attrib_t))) {
        RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
        CalibDbV2_MFNR_t* mfnr =
            (CalibDbV2_MFNR_t*)CALIBDBV2_GET_MODULE_PTR((void*)(sharedCom->calibv2), mfnr_v1);
        if (mfnr && mfnr->TuningPara.enable && mfnr->TuningPara.motion_detect_en) {
            if ((att->eMode == ANR_OP_MODE_AUTO) && (!att->stAuto.mfnrEn)) {
                att->stAuto.mfnrEn = !att->stAuto.mfnrEn;
                LOGE("motion detect is running, operate not permit!");
                goto EXIT;
            } else if ((att->eMode == ANR_OP_MODE_MANUAL) && (!att->stManual.mfnrEn)) {
                att->stManual.mfnrEn = !att->stManual.mfnrEn;
                LOGE("motion detect is running, operate not permit!");
                goto EXIT;
            }
        }
        mNewAtt = *att;
        updateAtt = true;
        waitSignal();
    }
EXIT:
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::getAttrib(rk_aiq_nr_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = rk_aiq_uapi_anr_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::setIQPara(rk_aiq_nr_IQPara_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQpara, para, sizeof(rk_aiq_nr_IQPara_t))) {
        RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
        CalibDbV2_MFNR_t* mfnr =
            (CalibDbV2_MFNR_t*)CALIBDBV2_GET_MODULE_PTR((void*)(sharedCom->calibv2), mfnr_v1);
        if (mfnr && mfnr->TuningPara.enable && mfnr->TuningPara.motion_detect_en) {
            if((para->module_bits & (1 << ANR_MODULE_MFNR)) && !para->stMfnrPara.enable) {
                para->stMfnrPara.enable = !para->stMfnrPara.enable;
                LOGE("motion detect is running, disable mfnr is not permit!");
            }
        }
        mNewIQpara = *para;
        UpdateIQpara = true;
        waitSignal();
    }
EXIT:
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::getIQPara(rk_aiq_nr_IQPara_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = rk_aiq_uapi_anr_GetIQPara(mAlgoCtx, para);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAnrHandleInt::setLumaSFStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_SetLumaSFStrength(mAlgoCtx, fPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::setLumaTFStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_SetLumaTFStrength(mAlgoCtx, fPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::getLumaSFStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_GetLumaSFStrength(mAlgoCtx, pPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::getLumaTFStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_GetLumaTFStrength(mAlgoCtx, pPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::setChromaSFStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_SetChromaSFStrength(mAlgoCtx, fPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::setChromaTFStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_SetChromaTFStrength(mAlgoCtx, fPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::getChromaSFStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_GetChromaSFStrength(mAlgoCtx, pPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::getChromaTFStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_GetChromaTFStrength(mAlgoCtx, pPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::setRawnrSFStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_SetRawnrSFStrength(mAlgoCtx, fPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::getRawnrSFStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ret = rk_aiq_uapi_anr_GetRawnrSFStrength(mAlgoCtx, pPercent);
    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAnrHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "anr handle prepare failed");

    RkAiqAlgoConfigAnrInt* anr_config_int = (RkAiqAlgoConfigAnrInt*)mConfig;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "anr algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAnrHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAnrInt* anr_pre_int = (RkAiqAlgoPreAnrInt*)mPreInParam;
    RkAiqAlgoPreResAnrInt* anr_pre_res_int = (RkAiqAlgoPreResAnrInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAnrHandle::preProcess();
    if (ret) {
        comb->anr_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "anr handle preProcess failed");
    }

    comb->anr_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "anr algo pre_process failed");

    // set result to mAiqCore
    comb->anr_pre_res = (RkAiqAlgoPreResAnr*)anr_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAnrHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAnrInt* anr_proc_int = (RkAiqAlgoProcAnrInt*)mProcInParam;
    RkAiqAlgoProcResAnrInt* anr_proc_res_int = (RkAiqAlgoProcResAnrInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;
    static int anr_proc_framecnt = 0;
    anr_proc_framecnt++;

    ret = RkAiqAnrHandle::processing();
    if (ret) {
        comb->anr_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "anr handle processing failed");
    }
    comb->anr_proc_res = NULL;

    // TODO: fill procParam
    anr_proc_int->iso = sharedCom->iso;

    anr_proc_int->hdr_mode = sharedCom->working_mode;

    LOGD("%s:%d anr hdr_mode:%d  \n", __FUNCTION__, __LINE__, anr_proc_int->hdr_mode);


    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "anr algo processing failed");

    comb->anr_proc_res = (RkAiqAlgoProcResAnr*)anr_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAnrHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAnrInt* anr_post_int = (RkAiqAlgoPostAnrInt*)mPostInParam;
    RkAiqAlgoPostResAnrInt* anr_post_res_int = (RkAiqAlgoPostResAnrInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAnrHandle::postProcess();
    if (ret) {
        comb->anr_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "anr handle postProcess failed");
        return ret;
    }

    comb->anr_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "anr algo post_process failed");
    // set result to mAiqCore
    comb->anr_post_res = (RkAiqAlgoPostResAnr*)anr_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAsharpHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAsharpHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAsharpInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAsharpInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAsharpInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAsharpInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAsharpInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAsharpInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAsharpInt());

    EXIT_ANALYZER_FUNCTION();
}


XCamReturn
RkAiqAsharpHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_asharp_SetAttrib(mAlgoCtx, &mCurAtt, false);
        sendSignal();
    }

    if(updateIQpara) {
        mCurIQPara = mNewIQPara;
        updateIQpara = false;
        // TODO
        rk_aiq_uapi_asharp_SetIQpara(mAlgoCtx, &mCurIQPara, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAsharpHandleInt::setAttrib(rk_aiq_sharp_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_sharp_attrib_t))) {
        mNewAtt = *att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAsharpHandleInt::getAttrib(rk_aiq_sharp_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_asharp_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAsharpHandleInt::setIQPara(rk_aiq_sharp_IQpara_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_sharp_IQpara_t))) {
        mNewIQPara = *para;
        updateIQpara = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAsharpHandleInt::getIQPara(rk_aiq_sharp_IQpara_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_asharp_GetIQpara(mAlgoCtx, para);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAsharpHandleInt::setStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_asharp_SetStrength(mAlgoCtx, fPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAsharpHandleInt::getStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_asharp_GetStrength(mAlgoCtx, pPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAsharpHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAsharpHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "asharp handle prepare failed");

    RkAiqAlgoConfigAsharpInt* asharp_config_int = (RkAiqAlgoConfigAsharpInt*)mConfig;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "asharp algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAsharpHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAsharpInt* asharp_pre_int = (RkAiqAlgoPreAsharpInt*)mPreInParam;
    RkAiqAlgoPreResAsharpInt* asharp_pre_res_int = (RkAiqAlgoPreResAsharpInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAsharpHandle::preProcess();
    if (ret) {
        comb->asharp_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "asharp handle preProcess failed");
    }

    comb->asharp_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "asharp algo pre_process failed");
    // set result to mAiqCore
    comb->asharp_pre_res = (RkAiqAlgoPreResAsharp*)asharp_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAsharpHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAsharpInt* asharp_proc_int = (RkAiqAlgoProcAsharpInt*)mProcInParam;
    RkAiqAlgoProcResAsharpInt* asharp_proc_res_int = (RkAiqAlgoProcResAsharpInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;
    static int asharp_proc_framecnt = 0;
    asharp_proc_framecnt++;

    ret = RkAiqAsharpHandle::processing();
    if (ret) {
        comb->asharp_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "asharp handle processing failed");
    }

    comb->asharp_proc_res = NULL;

    // TODO: fill procParam
    asharp_proc_int->iso = sharedCom->iso;
    asharp_proc_int->hdr_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "asharp algo processing failed");

    comb->asharp_proc_res = (RkAiqAlgoProcResAsharp*)asharp_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAsharpHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAsharpInt* asharp_post_int = (RkAiqAlgoPostAsharpInt*)mPostInParam;
    RkAiqAlgoPostResAsharpInt* asharp_post_res_int = (RkAiqAlgoPostResAsharpInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAsharpHandle::postProcess();
    if (ret) {
        comb->asharp_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "asharp handle postProcess failed");
        return ret;
    }

    comb->asharp_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "asharp algo post_process failed");
    // set result to mAiqCore
    comb->asharp_post_res = (RkAiqAlgoPostResAsharp*)asharp_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAdhazHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAdhazHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAdhazInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAdhazInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAdhazInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAdhazInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAdhazInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAdhazInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAdhazInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAdhazHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAdhazHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "adhaz handle prepare failed");

    RkAiqAlgoConfigAdhazInt* adhaz_config_int = (RkAiqAlgoConfigAdhazInt*)mConfig;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    adhaz_config_int->calib = sharedCom->calib;

    adhaz_config_int->working_mode = sharedCom->working_mode;
    // adhaz_config_int->rawHeight = sharedCom->snsDes.isp_acq_height;
    // adhaz_config_int->rawWidth = sharedCom->snsDes.isp_acq_width;
    // adhaz_config_int->working_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "adhaz algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAdhazHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAdhazInt* adhaz_pre_int = (RkAiqAlgoPreAdhazInt*)mPreInParam;
    RkAiqAlgoPreResAdhazInt* adhaz_pre_res_int = (RkAiqAlgoPreResAdhazInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;
    RkAiqPreResComb* comb = &shared->preResComb;

    adhaz_pre_int->rawHeight = sharedCom->snsDes.isp_acq_height;
    adhaz_pre_int->rawWidth = sharedCom->snsDes.isp_acq_width;

    ret = RkAiqAdhazHandle::preProcess();
    if (ret) {
        comb->adhaz_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adhaz handle preProcess failed");
    }

    comb->adhaz_pre_res = NULL;

#ifdef RK_SIMULATOR_HW
    //nothing todo
#endif
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "adhaz algo pre_process failed");

    // set result to mAiqCore
    comb->adhaz_pre_res = (RkAiqAlgoPreResAdhaz*)adhaz_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAdhazHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAdhazInt* adhaz_proc_int = (RkAiqAlgoProcAdhazInt*)mProcInParam;
    RkAiqAlgoProcResAdhazInt* adhaz_proc_res_int = (RkAiqAlgoProcResAdhazInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    adhaz_proc_int->hdr_mode = sharedCom->working_mode;

    ret = RkAiqAdhazHandle::processing();
    if (ret) {
        comb->adhaz_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adhaz handle processing failed");
    }

    if(!shared->ispStats->adehaze_stats_valid && !sharedCom->init) {
        LOGD("no adehaze stats, ignore!");
        // TODO: keep last result ?
        //
        //
        return XCAM_RETURN_BYPASS;
    } else {
        if(sharedCom->ctxCfigs[RK_AIQ_ALGO_TYPE_ADHAZ].cfg_com.isp_hw_version == 0)
            memcpy(&adhaz_proc_int->stats.dehaze_stats_v20, &ispStats->adehaze_stats.dehaze_stats_v20, sizeof(dehaze_stats_v20_t));
        else if(sharedCom->ctxCfigs[RK_AIQ_ALGO_TYPE_ADHAZ].cfg_com.isp_hw_version == 1)
            memcpy(&adhaz_proc_int->stats.dehaze_stats_v21, &ispStats->adehaze_stats.dehaze_stats_v21, sizeof(dehaze_stats_v21_t));
        memcpy(adhaz_proc_int->stats.other_stats.tmo_luma,
               ispStats->aec_stats.ae_data.extra.rawae_big.channelg_xy, sizeof(adhaz_proc_int->stats.other_stats.tmo_luma));

        if(sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR || sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR)
        {
            memcpy(adhaz_proc_int->stats.other_stats.short_luma,
                   ispStats->aec_stats.ae_data.chn[0].rawae_big.channelg_xy, sizeof(adhaz_proc_int->stats.other_stats.short_luma));
            memcpy(adhaz_proc_int->stats.other_stats.middle_luma,
                   ispStats->aec_stats.ae_data.chn[1].rawae_lite.channelg_xy, sizeof(adhaz_proc_int->stats.other_stats.middle_luma));
            memcpy(adhaz_proc_int->stats.other_stats.long_luma,
                   ispStats->aec_stats.ae_data.chn[2].rawae_big.channelg_xy, sizeof(adhaz_proc_int->stats.other_stats.long_luma));
        }
        else if(sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR || sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR)
        {
            memcpy(adhaz_proc_int->stats.other_stats.short_luma,
                   ispStats->aec_stats.ae_data.chn[0].rawae_big.channelg_xy, sizeof(adhaz_proc_int->stats.other_stats.short_luma));
            memcpy(adhaz_proc_int->stats.other_stats.long_luma,
                   ispStats->aec_stats.ae_data.chn[1].rawae_big.channelg_xy, sizeof(adhaz_proc_int->stats.other_stats.long_luma));
        }
        else
            LOGD("Wrong working mode!!!");
    }

    adhaz_proc_int->pCalibDehaze = sharedCom->calib;

    comb->adhaz_proc_res = NULL;

#ifdef RK_SIMULATOR_HW
    //nothing todo
#endif
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "adhaz algo processing failed");

    comb->adhaz_proc_res = (RkAiqAlgoProcResAdhaz*)adhaz_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdhazHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAdhazInt* adhaz_post_int = (RkAiqAlgoPostAdhazInt*)mPostInParam;
    RkAiqAlgoPostResAdhazInt* adhaz_post_res_int = (RkAiqAlgoPostResAdhazInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdhazHandle::postProcess();
    if (ret) {
        comb->adhaz_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adhaz handle postProcess failed");
        return ret;
    }

    comb->adhaz_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "adhaz algo post_process failed");
    // set result to mAiqCore
    comb->adhaz_post_res = (RkAiqAlgoPostResAdhaz*)adhaz_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdhazHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_adehaze_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdhazHandleInt::setSwAttrib(adehaze_sw_s att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(adehaze_sw_s))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdhazHandleInt::getSwAttrib(adehaze_sw_s *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_adehaze_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAmergeHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAmergeHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAmergeInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAmergeInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAmergeInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAmergeInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAmergeInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAmergeInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAmergeInt());

    EXIT_ANALYZER_FUNCTION();
}
XCamReturn
RkAiqAmergeHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_amerge_SetAttrib(mAlgoCtx, mCurAtt, true);
        sendSignal();
    }
    if (needSync)
        mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmergeHandleInt::setAttrib(amerge_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(amerge_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAmergeHandleInt::getAttrib(amerge_attrib_t* att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_amerge_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmergeHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAmergeHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "amerge handle prepare failed");

    RkAiqAlgoConfigAmergeInt* amerge_config_int = (RkAiqAlgoConfigAmergeInt*)mConfig;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    //TODO
    amerge_config_int->rawHeight = sharedCom->snsDes.isp_acq_height;
    amerge_config_int->rawWidth = sharedCom->snsDes.isp_acq_width;
    amerge_config_int->working_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "amerge algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAmergeHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAmergeInt* amerge_pre_int = (RkAiqAlgoPreAmergeInt*)mPreInParam;
    RkAiqAlgoPreResAmergeInt* amerge_pre_res_int = (RkAiqAlgoPreResAmergeInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    ret = RkAiqAmergeHandle::preProcess();
    if (ret) {
        comb->amerge_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "amerge handle preProcess failed");
    }

    comb->amerge_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "amerge algo pre_process failed");

    // set result to mAiqCore
    comb->amerge_pre_res = (RkAiqAlgoPreResAmerge*)amerge_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAmergeHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAmergeInt* amerge_proc_int = (RkAiqAlgoProcAmergeInt*)mProcInParam;
    RkAiqAlgoProcResAmergeInt* amerge_proc_res_int = (RkAiqAlgoProcResAmergeInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    ret = RkAiqAmergeHandle::processing();
    if (ret) {
        comb->amerge_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "amerge handle processing failed");
    }

    comb->amerge_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "amerge algo processing failed");

    comb->amerge_proc_res = (RkAiqAlgoProcResAmerge*)amerge_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmergeHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAmergeInt* amerge_post_int = (RkAiqAlgoPostAmergeInt*)mPostInParam;
    RkAiqAlgoPostResAmergeInt* amerge_post_res_int = (RkAiqAlgoPostResAmergeInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    ret = RkAiqAmergeHandle::postProcess();
    if (ret) {
        comb->amerge_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "amerge handle postProcess failed");
        return ret;
    }

    comb->amerge_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "amerge algo post_process failed");
    // set result to mAiqCore
    comb->amerge_post_res = (RkAiqAlgoPostResAmerge*)amerge_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAtmoHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAtmoHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAtmoInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAtmoInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAtmoInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAtmoInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAtmoInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAtmoInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAtmoInt());

    EXIT_ANALYZER_FUNCTION();
}
XCamReturn
RkAiqAtmoHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_atmo_SetAttrib(mAlgoCtx, mCurAtt, true);
        sendSignal();
    }
    if (needSync)
        mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAtmoHandleInt::setAttrib(atmo_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(atmo_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAtmoHandleInt::getAttrib(atmo_attrib_t* att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_atmo_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAtmoHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAtmoHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "atmo handle prepare failed");

    RkAiqAlgoConfigAtmoInt* atmo_config_int = (RkAiqAlgoConfigAtmoInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    //TODO
    atmo_config_int->rawHeight = sharedCom->snsDes.isp_acq_height;
    atmo_config_int->rawWidth = sharedCom->snsDes.isp_acq_width;
    atmo_config_int->working_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "atmo algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAtmoHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAtmoInt* atmo_pre_int = (RkAiqAlgoPreAtmoInt*)mPreInParam;
    RkAiqAlgoPreResAtmoInt* atmo_pre_res_int = (RkAiqAlgoPreResAtmoInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    ret = RkAiqAtmoHandle::preProcess();
    if (ret) {
        comb->atmo_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "atmo handle preProcess failed");
    }

    if(!shared->ispStats->atmo_stats_valid && !sharedCom->init) {
        LOGD("no atmo stats, ignore!");
        // TODO: keep last result ?
        //         comb->atmo_proc_res = NULL;
        //
        return XCAM_RETURN_BYPASS;
    }

    comb->atmo_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "ahdr algo pre_process failed");

    // set result to mAiqCore
    comb->atmo_pre_res = (RkAiqAlgoPreResAtmo*)atmo_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAtmoHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAtmoInt* atmo_proc_int = (RkAiqAlgoProcAtmoInt*)mProcInParam;
    RkAiqAlgoProcResAtmoInt* atmo_proc_res_int = (RkAiqAlgoProcResAtmoInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    ret = RkAiqAtmoHandle::processing();
    if (ret) {
        comb->atmo_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "atmo handle processing failed");
    }

    if(!shared->ispStats->atmo_stats_valid && !sharedCom->init) {
        LOGD("no atmo stats, ignore!");
        // TODO: keep last result ?
        //         comb->atmo_proc_res = NULL;
        //
        return XCAM_RETURN_BYPASS;
    } else {
        memcpy(&atmo_proc_int->ispAtmoStats.tmo_stats, &ispStats->atmo_stats.tmo_stats, sizeof(hdrtmo_stats_t));
        memcpy(atmo_proc_int->ispAtmoStats.other_stats.tmo_luma,
               ispStats->aec_stats.ae_data.extra.rawae_big.channelg_xy, sizeof(atmo_proc_int->ispAtmoStats.other_stats.tmo_luma));

        if(sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR || sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR)
        {
            memcpy(atmo_proc_int->ispAtmoStats.other_stats.short_luma,
                   ispStats->aec_stats.ae_data.chn[0].rawae_big.channelg_xy, sizeof(atmo_proc_int->ispAtmoStats.other_stats.short_luma));
            memcpy(atmo_proc_int->ispAtmoStats.other_stats.middle_luma,
                   ispStats->aec_stats.ae_data.chn[1].rawae_lite.channelg_xy, sizeof(atmo_proc_int->ispAtmoStats.other_stats.middle_luma));
            memcpy(atmo_proc_int->ispAtmoStats.other_stats.long_luma,
                   ispStats->aec_stats.ae_data.chn[2].rawae_big.channelg_xy, sizeof(atmo_proc_int->ispAtmoStats.other_stats.long_luma));
        }
        else if(sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR || sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR)
        {
            memcpy(atmo_proc_int->ispAtmoStats.other_stats.short_luma,
                   ispStats->aec_stats.ae_data.chn[0].rawae_big.channelg_xy, sizeof(atmo_proc_int->ispAtmoStats.other_stats.short_luma));
            memcpy(atmo_proc_int->ispAtmoStats.other_stats.long_luma,
                   ispStats->aec_stats.ae_data.chn[1].rawae_big.channelg_xy, sizeof(atmo_proc_int->ispAtmoStats.other_stats.long_luma));
        }
        else
            LOGD("Wrong working mode!!!");
    }

    comb->atmo_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "atmo algo processing failed");

    comb->atmo_proc_res = (RkAiqAlgoProcResAtmo*)atmo_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAtmoHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAtmoInt* atmo_post_int = (RkAiqAlgoPostAtmoInt*)mPostInParam;
    RkAiqAlgoPostResAtmoInt* atmo_post_res_int = (RkAiqAlgoPostResAtmoInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    ret = RkAiqAtmoHandle::postProcess();
    if (ret) {
        comb->atmo_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ahdr handle postProcess failed");
        return ret;
    }

    if(!shared->ispStats->atmo_stats_valid && !sharedCom->init) {
        LOGD("no atmo stats, ignore!");
        // TODO: keep last result ?
        //         comb->ahdr_proc_res = NULL;
        //
        return XCAM_RETURN_BYPASS;
    }

    comb->atmo_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "atmo algo post_process failed");
    // set result to mAiqCore
    comb->atmo_post_res = (RkAiqAlgoPostResAtmo*)atmo_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAsdHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAsdHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAsdInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAsdInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAsdInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAsdInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAsdInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAsdInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAsdInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAsdHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_asd_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAsdHandleInt::setAttrib(asd_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(asd_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAsdHandleInt::getAttrib(asd_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_asd_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAsdHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAsdHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "asd handle prepare failed");

    RkAiqAlgoConfigAsdInt* asd_config_int = (RkAiqAlgoConfigAsdInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "asd algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAsdHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAsdInt* asd_pre_int = (RkAiqAlgoPreAsdInt*)mPreInParam;
    RkAiqAlgoPreResAsdInt* asd_pre_res_int = (RkAiqAlgoPreResAsdInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAsdHandle::preProcess();
    if (ret) {
        comb->asd_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "asd handle preProcess failed");
    }

    comb->asd_pre_res = NULL;
    asd_pre_int->pre_params.cpsl_mode = sharedCom->cpslCfg.mode;
    asd_pre_int->pre_params.cpsl_on = sharedCom->cpslCfg.u.m.on;
    asd_pre_int->pre_params.cpsl_sensitivity = sharedCom->cpslCfg.u.a.sensitivity;
    asd_pre_int->pre_params.cpsl_sw_interval = sharedCom->cpslCfg.u.a.sw_interval;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "asd algo pre_process failed");

    // set result to mAiqCore
    comb->asd_pre_res = (RkAiqAlgoPreResAsd*)asd_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAsdHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAsdInt* asd_proc_int = (RkAiqAlgoProcAsdInt*)mProcInParam;
    RkAiqAlgoProcResAsdInt* asd_proc_res_int = (RkAiqAlgoProcResAsdInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAsdHandle::processing();
    if (ret) {
        comb->asd_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "asd handle processing failed");
    }

    comb->asd_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "asd algo processing failed");

    comb->asd_proc_res = (RkAiqAlgoProcResAsd*)asd_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAsdHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAsdInt* asd_post_int = (RkAiqAlgoPostAsdInt*)mPostInParam;
    RkAiqAlgoPostResAsdInt* asd_post_res_int = (RkAiqAlgoPostResAsdInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAsdHandle::postProcess();
    if (ret) {
        comb->asd_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "asd handle postProcess failed");
        return ret;
    }

    comb->asd_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "asd algo post_process failed");
    // set result to mAiqCore
    comb->asd_post_res = (RkAiqAlgoPostResAsd*)asd_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAcpHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAcpHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAcpInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAcpInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAcpInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAcpInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAcpInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAcpInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAcpInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAcpHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_acp_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }
    if (needSync)
        mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcpHandleInt::setAttrib(acp_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore
    if (0 != memcmp(&mCurAtt, &att, sizeof(acp_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcpHandleInt::getAttrib(acp_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_acp_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcpHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAcpHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "acp handle prepare failed");

    RkAiqAlgoConfigAcpInt* acp_config_int = (RkAiqAlgoConfigAcpInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "acp algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAcpHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAcpInt* acp_pre_int = (RkAiqAlgoPreAcpInt*)mPreInParam;
    RkAiqAlgoPreResAcpInt* acp_pre_res_int = (RkAiqAlgoPreResAcpInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAcpHandle::preProcess();
    if (ret) {
        comb->acp_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "acp handle preProcess failed");
    }

    comb->acp_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "acp algo pre_process failed");

    // set result to mAiqCore
    comb->acp_pre_res = (RkAiqAlgoPreResAcp*)acp_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAcpHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAcpInt* acp_proc_int = (RkAiqAlgoProcAcpInt*)mProcInParam;
    RkAiqAlgoProcResAcpInt* acp_proc_res_int = (RkAiqAlgoProcResAcpInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAcpHandle::processing();
    if (ret) {
        comb->acp_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "acp handle processing failed");
    }

    comb->acp_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "acp algo processing failed");

    comb->acp_proc_res = (RkAiqAlgoProcResAcp*)acp_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcpHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAcpInt* acp_post_int = (RkAiqAlgoPostAcpInt*)mPostInParam;
    RkAiqAlgoPostResAcpInt* acp_post_res_int = (RkAiqAlgoPostResAcpInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAcpHandle::postProcess();
    if (ret) {
        comb->acp_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "acp handle postProcess failed");
        return ret;
    }

    comb->acp_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "acp algo post_process failed");
    // set result to mAiqCore
    comb->acp_post_res = (RkAiqAlgoPostResAcp*)acp_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqA3dlutHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqA3dlutHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigA3dlutInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreA3dlutInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResA3dlutInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcA3dlutInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResA3dlutInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostA3dlutInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResA3dlutInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqA3dlutHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_a3dlut_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqA3dlutHandleInt::setAttrib(rk_aiq_lut3d_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_lut3d_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqA3dlutHandleInt::getAttrib(rk_aiq_lut3d_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_a3dlut_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqA3dlutHandleInt::query3dlutInfo(rk_aiq_lut3d_querry_info_t *lut3d_querry_info )
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_a3dlut_Query3dlutInfo(mAlgoCtx, lut3d_querry_info);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqA3dlutHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqA3dlutHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "a3dlut handle prepare failed");

    RkAiqAlgoConfigA3dlutInt* a3dlut_config_int = (RkAiqAlgoConfigA3dlutInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "a3dlut algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqA3dlutHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreA3dlutInt* a3dlut_pre_int = (RkAiqAlgoPreA3dlutInt*)mPreInParam;
    RkAiqAlgoPreResA3dlutInt* a3dlut_pre_res_int = (RkAiqAlgoPreResA3dlutInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqA3dlutHandle::preProcess();
    if (ret) {
        comb->a3dlut_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "a3dlut handle preProcess failed");
    }

    comb->a3dlut_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "a3dlut algo pre_process failed");

    // set result to mAiqCore
    comb->a3dlut_pre_res = (RkAiqAlgoPreResA3dlut*)a3dlut_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqA3dlutHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcA3dlutInt* a3dlut_proc_int = (RkAiqAlgoProcA3dlutInt*)mProcInParam;
    RkAiqAlgoProcResA3dlutInt* a3dlut_proc_res_int = (RkAiqAlgoProcResA3dlutInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqA3dlutHandle::processing();
    if (ret) {
        comb->a3dlut_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "a3dlut handle processing failed");
    }

    comb->a3dlut_proc_res = NULL;
    XCamVideoBuffer* xCamAwbProcRes = shared->res_comb.awb_proc_res;
    if (xCamAwbProcRes) {
        RkAiqAlgoProcResAwbInt* awb_res_int = (RkAiqAlgoProcResAwbInt*)xCamAwbProcRes->map(xCamAwbProcRes);
        RkAiqAlgoProcResAwb* awb_res = &awb_res_int->awb_proc_res_com;
        if(awb_res) {
            if(awb_res->awb_gain_algo.grgain < DIVMIN ||
                    awb_res->awb_gain_algo.gbgain < DIVMIN ) {
                LOGE("get wrong awb gain from AWB module ,use default value ");
            } else {
                a3dlut_proc_int->awbGain[0] =
                    awb_res->awb_gain_algo.rgain / awb_res->awb_gain_algo.grgain;

                a3dlut_proc_int->awbGain[1] =
                    awb_res->awb_gain_algo.bgain / awb_res->awb_gain_algo.gbgain;
            }
            a3dlut_proc_int->awbIIRDampCoef =  awb_res_int->awb_smooth_factor;
            a3dlut_proc_int->awbConverged = awb_res_int->awbConverged;
        } else {
            LOGE("fail to get awb gain form AWB module,use default value ");
        }
    } else {
        LOGE("fail to get awb gain form AWB module,use default value ");
    }
    RKAiqAecExpInfo_t *pCurExp = &shared->curExp;
    if(pCurExp) {
        if((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
            a3dlut_proc_int->sensorGain = pCurExp->LinearExp.exp_real_params.analog_gain
                                          * pCurExp->LinearExp.exp_real_params.digital_gain
                                          * pCurExp->LinearExp.exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("sensor gain choose from second hdr frame for a3dlut");
            a3dlut_proc_int->sensorGain = pCurExp->HdrExp[1].exp_real_params.analog_gain
                                          * pCurExp->HdrExp[1].exp_real_params.digital_gain
                                          * pCurExp->HdrExp[1].exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("sensor gain choose from third hdr frame for a3dlut");
            a3dlut_proc_int->sensorGain = pCurExp->HdrExp[2].exp_real_params.analog_gain
                                          * pCurExp->HdrExp[2].exp_real_params.digital_gain
                                          * pCurExp->HdrExp[2].exp_real_params.isp_dgain;
        } else {
            LOGE("working_mode (%d) is invaild ,fail to get sensor gain form AE module,use default value ",
                 sharedCom->working_mode);
        }
    } else {
        LOGE("fail to get sensor gain form AE module,use default value ");
    }

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "a3dlut algo processing failed");

    comb->a3dlut_proc_res = (RkAiqAlgoProcResA3dlut*)a3dlut_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqA3dlutHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostA3dlutInt* a3dlut_post_int = (RkAiqAlgoPostA3dlutInt*)mPostInParam;
    RkAiqAlgoPostResA3dlutInt* a3dlut_post_res_int = (RkAiqAlgoPostResA3dlutInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqA3dlutHandle::postProcess();
    if (ret) {
        comb->a3dlut_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "a3dlut handle postProcess failed");
        return ret;
    }

    comb->a3dlut_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "a3dlut algo post_process failed");
    // set result to mAiqCore
    comb->a3dlut_post_res = (RkAiqAlgoPostResA3dlut*)a3dlut_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAblcHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAblcHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAblcInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAblcInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAblcInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAblcInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAblcInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAblcInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAblcInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAblcHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_ablc_SetAttrib(mAlgoCtx, &mCurAtt, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAblcHandleInt::setAttrib(rk_aiq_blc_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_blc_attrib_t))) {
        mNewAtt = *att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAblcHandleInt::getAttrib(rk_aiq_blc_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_ablc_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAblcHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAblcHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "ablc handle prepare failed");

    RkAiqAlgoConfigAblcInt* ablc_config_int = (RkAiqAlgoConfigAblcInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "ablc algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAblcHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAblcInt* ablc_pre_int = (RkAiqAlgoPreAblcInt*)mPreInParam;
    RkAiqAlgoPreResAblcInt* ablc_pre_res_int = (RkAiqAlgoPreResAblcInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAblcHandle::preProcess();
    if (ret) {
        comb->ablc_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ablc handle preProcess failed");
    }

    comb->ablc_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "ablc algo pre_process failed");

    // set result to mAiqCore
    comb->ablc_pre_res = (RkAiqAlgoPreResAblc*)ablc_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAblcHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAblcInt* ablc_proc_int = (RkAiqAlgoProcAblcInt*)mProcInParam;
    RkAiqAlgoProcResAblcInt* ablc_proc_res_int = (RkAiqAlgoProcResAblcInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAblcHandle::processing();
    if (ret) {
        comb->ablc_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ablc handle processing failed");
    }

    comb->ablc_proc_res = NULL;
    ablc_proc_int->iso = sharedCom->iso;
    ablc_proc_int->hdr_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "ablc algo processing failed");

    comb->ablc_proc_res = (RkAiqAlgoProcResAblc*)ablc_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAblcHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAblcInt* ablc_post_int = (RkAiqAlgoPostAblcInt*)mPostInParam;
    RkAiqAlgoPostResAblcInt* ablc_post_res_int = (RkAiqAlgoPostResAblcInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAblcHandle::postProcess();
    if (ret) {
        comb->ablc_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ablc handle postProcess failed");
        return ret;
    }

    comb->ablc_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "ablc algo post_process failed");
    // set result to mAiqCore
    comb->ablc_post_res = (RkAiqAlgoPostResAblc*)ablc_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAccmHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAccmHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAccmInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAccmInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAccmInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAccmInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAccmInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAccmInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAccmInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAccmHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_accm_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAccmHandleInt::setAttrib(rk_aiq_ccm_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_ccm_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAccmHandleInt::getAttrib(rk_aiq_ccm_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_accm_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAccmHandleInt::queryCcmInfo(rk_aiq_ccm_querry_info_t *ccm_querry_info )
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_accm_QueryCcmInfo(mAlgoCtx, ccm_querry_info);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAccmHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAccmHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "accm handle prepare failed");

    RkAiqAlgoConfigAccmInt* accm_config_int = (RkAiqAlgoConfigAccmInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "accm algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAccmHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAccmInt* accm_pre_int = (RkAiqAlgoPreAccmInt*)mPreInParam;
    RkAiqAlgoPreResAccmInt* accm_pre_res_int = (RkAiqAlgoPreResAccmInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAccmHandle::preProcess();
    if (ret) {
        comb->accm_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "accm handle preProcess failed");
    }

    comb->accm_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "accm algo pre_process failed");

    // set result to mAiqCore
    comb->accm_pre_res = (RkAiqAlgoPreResAccm*)accm_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAccmHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAccmInt* accm_proc_int = (RkAiqAlgoProcAccmInt*)mProcInParam;
    RkAiqAlgoProcResAccmInt* accm_proc_res_int = (RkAiqAlgoProcResAccmInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAccmHandle::processing();
    if (ret) {
        comb->accm_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "accm handle processing failed");
    }

    comb->accm_proc_res = NULL;
    // TODO should check if the rk awb algo used
#if 0
    RkAiqAlgoProcResAwb* awb_res =
        (RkAiqAlgoProcResAwb*)(shared->procResComb.awb_proc_res);
    RkAiqAlgoProcResAwbInt* awb_res_int =
        (RkAiqAlgoProcResAwbInt*)(shared->procResComb.awb_proc_res);

    if(awb_res ) {
        if(awb_res->awb_gain_algo.grgain < DIVMIN ||
                awb_res->awb_gain_algo.gbgain < DIVMIN ) {
            LOGE("get wrong awb gain from AWB module ,use default value ");
        } else {
            accm_proc_int->accm_sw_info.awbGain[0] =
                awb_res->awb_gain_algo.rgain / awb_res->awb_gain_algo.grgain;

            accm_proc_int->accm_sw_info.awbGain[1] = awb_res->awb_gain_algo.bgain / awb_res->awb_gain_algo.gbgain;
        }
        accm_proc_int->accm_sw_info.awbIIRDampCoef =  awb_res_int->awb_smooth_factor;
        accm_proc_int->accm_sw_info.varianceLuma = awb_res_int->varianceLuma;
        accm_proc_int->accm_sw_info.awbConverged = awb_res_int->awbConverged;
    } else {
        LOGE("fail to get awb gain form AWB module,use default value ");
    }
    RkAiqAlgoPreResAeInt *ae_int = (RkAiqAlgoPreResAeInt*)shared->preResComb.ae_pre_res;
    if( ae_int) {
        if(sharedCom->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
            accm_proc_int->accm_sw_info.sensorGain = ae_int->ae_pre_res_rk.LinearExp.exp_real_params.analog_gain
                    * ae_int->ae_pre_res_rk.LinearExp.exp_real_params.digital_gain
                    * ae_int->ae_pre_res_rk.LinearExp.exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("%sensor gain choose from second hdr frame for accm");
            accm_proc_int->accm_sw_info.sensorGain = ae_int->ae_pre_res_rk.HdrExp[1].exp_real_params.analog_gain
                    * ae_int->ae_pre_res_rk.HdrExp[1].exp_real_params.digital_gain
                    * ae_int->ae_pre_res_rk.HdrExp[1].exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("sensor gain choose from third hdr frame for accm");
            accm_proc_int->accm_sw_info.sensorGain = ae_int->ae_pre_res_rk.HdrExp[2].exp_real_params.analog_gain
                    * ae_int->ae_pre_res_rk.HdrExp[2].exp_real_params.digital_gain
                    * ae_int->ae_pre_res_rk.HdrExp[2].exp_real_params.isp_dgain;
        } else {
            LOGE("working_mode (%d) is invaild ,fail to get sensor gain form AE module,use default value ",
                 sharedCom->working_mode);
        }
    } else {
        LOGE("fail to get sensor gain form AE module,use default value ");
    }
#else
    XCamVideoBuffer* xCamAwbProcRes = shared->res_comb.awb_proc_res;
    if (xCamAwbProcRes) {
        RkAiqAlgoProcResAwbInt* awb_res_int = (RkAiqAlgoProcResAwbInt*)xCamAwbProcRes->map(xCamAwbProcRes);
        RkAiqAlgoProcResAwb* awb_res = &awb_res_int->awb_proc_res_com;
        if(awb_res) {
            if(awb_res->awb_gain_algo.grgain < DIVMIN ||
                    awb_res->awb_gain_algo.gbgain < DIVMIN ) {
                LOGE("get wrong awb gain from AWB module ,use default value ");
            } else {
                accm_proc_int->accm_sw_info.awbGain[0] =
                    awb_res->awb_gain_algo.rgain / awb_res->awb_gain_algo.grgain;

                accm_proc_int->accm_sw_info.awbGain[1] =
                    awb_res->awb_gain_algo.bgain / awb_res->awb_gain_algo.gbgain;
            }
            accm_proc_int->accm_sw_info.awbIIRDampCoef =  awb_res_int->awb_smooth_factor;
            accm_proc_int->accm_sw_info.varianceLuma = awb_res_int->varianceLuma;
            accm_proc_int->accm_sw_info.awbConverged = awb_res_int->awbConverged;
        } else {
            LOGE("fail to get awb gain form AWB module,use default value ");
        }
    } else {
        LOGE("fail to get awb gain form AWB module,use default value ");
    }
    RKAiqAecExpInfo_t *pCurExp = &shared->curExp;
    if(pCurExp) {
        if((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
            accm_proc_int->accm_sw_info.sensorGain = pCurExp->LinearExp.exp_real_params.analog_gain
                    * pCurExp->LinearExp.exp_real_params.digital_gain
                    * pCurExp->LinearExp.exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("sensor gain choose from second hdr frame for accm");
            accm_proc_int->accm_sw_info.sensorGain = pCurExp->HdrExp[1].exp_real_params.analog_gain
                    * pCurExp->HdrExp[1].exp_real_params.digital_gain
                    * pCurExp->HdrExp[1].exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("sensor gain choose from third hdr frame for accm");
            accm_proc_int->accm_sw_info.sensorGain = pCurExp->HdrExp[2].exp_real_params.analog_gain
                    * pCurExp->HdrExp[2].exp_real_params.digital_gain
                    * pCurExp->HdrExp[2].exp_real_params.isp_dgain;
        } else {
            LOGE("working_mode (%d) is invaild ,fail to get sensor gain form AE module,use default value ",
                 sharedCom->working_mode);
        }
    } else {
        LOGE("fail to get sensor gain form AE module,use default value ");
    }
#endif

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "accm algo processing failed");

    comb->accm_proc_res = (RkAiqAlgoProcResAccm*)accm_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAccmHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAccmInt* accm_post_int = (RkAiqAlgoPostAccmInt*)mPostInParam;
    RkAiqAlgoPostResAccmInt* accm_post_res_int = (RkAiqAlgoPostResAccmInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAccmHandle::postProcess();
    if (ret) {
        comb->accm_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "accm handle postProcess failed");
        return ret;
    }

    comb->accm_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "accm algo post_process failed");
    // set result to mAiqCore
    comb->accm_post_res = (RkAiqAlgoPostResAccm*)accm_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAcgcHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAcgcHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAcgcInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAcgcInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAcgcInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAcgcInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAcgcInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAcgcInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAcgcInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAcgcHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAcgcHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "acgc handle prepare failed");

    RkAiqAlgoConfigAcgcInt* acgc_config_int = (RkAiqAlgoConfigAcgcInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "acgc algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAcgcHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAcgcInt* acgc_pre_int = (RkAiqAlgoPreAcgcInt*)mPreInParam;
    RkAiqAlgoPreResAcgcInt* acgc_pre_res_int = (RkAiqAlgoPreResAcgcInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAcgcHandle::preProcess();
    if (ret) {
        comb->acgc_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "acgc handle preProcess failed");
    }

    comb->acgc_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "acgc algo pre_process failed");

    // set result to mAiqCore
    comb->acgc_pre_res = (RkAiqAlgoPreResAcgc*)acgc_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAcgcHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAcgcInt* acgc_proc_int = (RkAiqAlgoProcAcgcInt*)mProcInParam;
    RkAiqAlgoProcResAcgcInt* acgc_proc_res_int = (RkAiqAlgoProcResAcgcInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAcgcHandle::processing();
    if (ret) {
        comb->acgc_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "acgc handle processing failed");
    }

    comb->acgc_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "acgc algo processing failed");

    comb->acgc_proc_res = (RkAiqAlgoProcResAcgc*)acgc_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcgcHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAcgcInt* acgc_post_int = (RkAiqAlgoPostAcgcInt*)mPostInParam;
    RkAiqAlgoPostResAcgcInt* acgc_post_res_int = (RkAiqAlgoPostResAcgcInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAcgcHandle::postProcess();
    if (ret) {
        comb->acgc_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "acgc handle postProcess failed");
        return ret;
    }

    comb->acgc_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "acgc algo post_process failed");
    // set result to mAiqCore
    comb->acgc_post_res = (RkAiqAlgoPostResAcgc*)acgc_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAdebayerHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAdebayerHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAdebayerInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAdebayerInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAdebayerInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAdebayerInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAdebayerInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAdebayerInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAdebayerInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAdebayerHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_adebayer_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }
    if (needSync)
        mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdebayerHandleInt::setAttrib(adebayer_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore
    if (0 != memcmp(&mCurAtt, &att, sizeof(adebayer_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdebayerHandleInt::getAttrib(adebayer_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_adebayer_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdebayerHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAdebayerHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "adebayer handle prepare failed");

    RkAiqAlgoConfigAdebayerInt* adebayer_config_int = (RkAiqAlgoConfigAdebayerInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "adebayer algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAdebayerHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAdebayerInt* adebayer_pre_int = (RkAiqAlgoPreAdebayerInt*)mPreInParam;
    RkAiqAlgoPreResAdebayerInt* adebayer_pre_res_int = (RkAiqAlgoPreResAdebayerInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdebayerHandle::preProcess();
    if (ret) {
        comb->adebayer_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adebayer handle preProcess failed");
    }

    comb->adebayer_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "adebayer algo pre_process failed");

    // set result to mAiqCore
    comb->adebayer_pre_res = (RkAiqAlgoPreResAdebayer*)adebayer_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAdebayerHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAdebayerInt* adebayer_proc_int = (RkAiqAlgoProcAdebayerInt*)mProcInParam;
    RkAiqAlgoProcResAdebayerInt* adebayer_proc_res_int = (RkAiqAlgoProcResAdebayerInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdebayerHandle::processing();
    if (ret) {
        comb->adebayer_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adebayer handle processing failed");
    }

    comb->adebayer_proc_res = NULL;
    // TODO: fill procParam
    adebayer_proc_int->hdr_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "adebayer algo processing failed");

    comb->adebayer_proc_res = (RkAiqAlgoProcResAdebayer*)adebayer_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdebayerHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAdebayerInt* adebayer_post_int = (RkAiqAlgoPostAdebayerInt*)mPostInParam;
    RkAiqAlgoPostResAdebayerInt* adebayer_post_res_int = (RkAiqAlgoPostResAdebayerInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdebayerHandle::postProcess();
    if (ret) {
        comb->adebayer_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adebayer handle postProcess failed");
        return ret;
    }

    comb->adebayer_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "adebayer algo post_process failed");
    // set result to mAiqCore
    comb->adebayer_post_res = (RkAiqAlgoPostResAdebayer*)adebayer_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAdpccHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAdpccHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAdpccInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAdpccInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAdpccInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAdpccInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAdpccInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAdpccInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAdpccInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAdpccHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_adpcc_SetAttrib(mAlgoCtx, &mCurAtt, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdpccHandleInt::setAttrib(rk_aiq_dpcc_attrib_V20_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_dpcc_attrib_V20_t))) {
        mNewAtt = *att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdpccHandleInt::getAttrib(rk_aiq_dpcc_attrib_V20_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_adpcc_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}



XCamReturn
RkAiqAdpccHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAdpccHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "adpcc handle prepare failed");

    RkAiqAlgoConfigAdpccInt* adpcc_config_int = (RkAiqAlgoConfigAdpccInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "adpcc algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAdpccHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAdpccInt* adpcc_pre_int = (RkAiqAlgoPreAdpccInt*)mPreInParam;
    RkAiqAlgoPreResAdpccInt* adpcc_pre_res_int = (RkAiqAlgoPreResAdpccInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdpccHandle::preProcess();
    if (ret) {
        comb->adpcc_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adpcc handle preProcess failed");
    }

    comb->adpcc_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "adpcc algo pre_process failed");

    // set result to mAiqCore
    comb->adpcc_pre_res = (RkAiqAlgoPreResAdpcc*)adpcc_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAdpccHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAdpccInt* adpcc_proc_int = (RkAiqAlgoProcAdpccInt*)mProcInParam;
    RkAiqAlgoProcResAdpccInt* adpcc_proc_res_int = (RkAiqAlgoProcResAdpccInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdpccHandle::processing();
    if (ret) {
        comb->adpcc_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adpcc handle processing failed");
    }

    comb->adpcc_proc_res = NULL;
    // TODO: fill procParam
    adpcc_proc_int->iso = sharedCom->iso;
    adpcc_proc_int->hdr_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "adpcc algo processing failed");

    comb->adpcc_proc_res = (RkAiqAlgoProcResAdpcc*)adpcc_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdpccHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAsdInt* asd_post_int = (RkAiqAlgoPostAsdInt*)mPostInParam;
    RkAiqAlgoPostResAsdInt* asd_post_res_int = (RkAiqAlgoPostResAsdInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdpccHandle::postProcess();
    if (ret) {
        comb->asd_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "asd handle postProcess failed");
        return ret;
    }

    comb->asd_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "asd algo post_process failed");
    // set result to mAiqCore
    comb->asd_post_res = (RkAiqAlgoPostResAsd*)asd_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAfecHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAfecHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAfecInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAfecInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAfecInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAfecInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAfecInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAfecInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAfecInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAfecHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAfecHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "afec handle prepare failed");

    RkAiqAlgoConfigAfecInt* afec_config_int = (RkAiqAlgoConfigAfecInt*)mConfig;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;

    /* memcpy(&afec_config_int->afec_calib_cfg, &shared->calib->afec, sizeof(CalibDb_FEC_t)); */
    afec_config_int->resource_path = sharedCom->resourcePath;
    afec_config_int->mem_ops_ptr = mAiqCore->mShareMemOps;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "afec algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAfecHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAfecInt* afec_pre_int = (RkAiqAlgoPreAfecInt*)mPreInParam;
    RkAiqAlgoPreResAfecInt* afec_pre_res_int = (RkAiqAlgoPreResAfecInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAfecHandle::preProcess();
    if (ret) {
        comb->afec_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "afec handle preProcess failed");
    }

    comb->afec_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "afec algo pre_process failed");

    // set result to mAiqCore
    comb->afec_pre_res = (RkAiqAlgoPreResAfec*)afec_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAfecHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAfecInt* afec_proc_int = (RkAiqAlgoProcAfecInt*)mProcInParam;
    RkAiqAlgoProcResAfecInt* afec_proc_res_int = (RkAiqAlgoProcResAfecInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAfecHandle::processing();
    if (ret) {
        comb->afec_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "afec handle processing failed");
    }

    comb->afec_proc_res = NULL;
    //fill procParam
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "afec algo processing failed");

    comb->afec_proc_res = (RkAiqAlgoProcResAfec*)afec_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfecHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAfecInt* afec_post_int = (RkAiqAlgoPostAfecInt*)mPostInParam;
    RkAiqAlgoPostResAfecInt* afec_post_res_int = (RkAiqAlgoPostResAfecInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAfecHandle::postProcess();
    if (ret) {
        comb->afec_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "afec handle postProcess failed");
        return ret;
    }

    comb->afec_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "afec algo post_process failed");
    // set result to mAiqCore
    comb->afec_post_res = (RkAiqAlgoPostResAfec*)afec_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfecHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_afec_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfecHandleInt::setAttrib(rk_aiq_fec_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_fec_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAfecHandleInt::getAttrib(rk_aiq_fec_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_afec_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAgammaHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAgammaHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAgammaInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAgammaInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAgammaInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAgammaInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAgammaInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAgammaInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAgammaInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAgammaHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_agamma_SetAttrib(mAlgoCtx, mCurAtt, false);
        waitSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAgammaHandleInt::setAttrib(rk_aiq_gamma_attrib_V2_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_gamma_attrib_V2_t))) {
        mNewAtt = att;
        updateAtt = true;
        sendSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAgammaHandleInt::getAttrib(rk_aiq_gamma_attrib_V2_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_agamma_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAgammaHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAgammaHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "agamma handle prepare failed");

    RkAiqAlgoConfigAgammaInt* agamma_config_int = (RkAiqAlgoConfigAgammaInt*)mConfig;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqIspStats* ispStats = shared->ispStats;

    agamma_config_int->calib = sharedCom->calib;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "agamma algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAgammaHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAgammaInt* agamma_pre_int = (RkAiqAlgoPreAgammaInt*)mPreInParam;
    RkAiqAlgoPreResAgammaInt* agamma_pre_res_int = (RkAiqAlgoPreResAgammaInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAgammaHandle::preProcess();
    if (ret) {
        comb->agamma_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "agamma handle preProcess failed");
    }

    comb->agamma_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "agamma algo pre_process failed");

    // set result to mAiqCore
    comb->agamma_pre_res = (RkAiqAlgoPreResAgamma*)agamma_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAgammaHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAgammaInt* agamma_proc_int = (RkAiqAlgoProcAgammaInt*)mProcInParam;
    RkAiqAlgoProcResAgammaInt* agamma_proc_res_int = (RkAiqAlgoProcResAgammaInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAgammaHandle::processing();
    if (ret) {
        comb->agamma_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "agamma handle processing failed");
    }

    comb->agamma_proc_res = NULL;
    agamma_proc_int->calib = sharedCom->calib;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "agamma algo processing failed");

    comb->agamma_proc_res = (RkAiqAlgoProcResAgamma*)agamma_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAgammaHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAgammaInt* agamma_post_int = (RkAiqAlgoPostAgammaInt*)mPostInParam;
    RkAiqAlgoPostResAgammaInt* agamma_post_res_int = (RkAiqAlgoPostResAgammaInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAgammaHandle::postProcess();
    if (ret) {
        comb->agamma_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "agamma handle postProcess failed");
        return ret;
    }

    comb->agamma_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "agamma algo post_process failed");
    // set result to mAiqCore
    comb->agamma_post_res = (RkAiqAlgoPostResAgamma*)agamma_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAdegammaHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAdegammaHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAdegammaInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAdegammaInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAdegammaInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAdegammaInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAdegammaInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAdegammaInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAdegammaInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAdegammaHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_adegamma_SetAttrib(mAlgoCtx, mCurAtt, false);
        waitSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdegammaHandleInt::setAttrib(rk_aiq_degamma_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_degamma_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        sendSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdegammaHandleInt::getAttrib(rk_aiq_degamma_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_adegamma_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAdegammaHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAdegammaHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "adegamma handle prepare failed");

    RkAiqAlgoConfigAdegammaInt* adegamma_config_int = (RkAiqAlgoConfigAdegammaInt*)mConfig;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    adegamma_config_int->calib = sharedCom->calib;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "adegamma algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAdegammaHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAdegammaInt* adegamma_pre_int = (RkAiqAlgoPreAdegammaInt*)mPreInParam;
    RkAiqAlgoPreResAdegammaInt* adegamma_pre_res_int = (RkAiqAlgoPreResAdegammaInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdegammaHandle::preProcess();
    if (ret) {
        comb->adegamma_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adegamma handle preProcess failed");
    }

    comb->adegamma_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "adegamma algo pre_process failed");

    // set result to mAiqCore
    comb->adegamma_pre_res = (RkAiqAlgoPreResAdegamma*)adegamma_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAdegammaHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAdegammaInt* adegamma_proc_int = (RkAiqAlgoProcAdegammaInt*)mProcInParam;
    RkAiqAlgoProcResAdegammaInt* adegamma_proc_res_int = (RkAiqAlgoProcResAdegammaInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdegammaHandle::processing();
    if (ret) {
        comb->adegamma_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adegamma handle processing failed");
    }

    comb->adegamma_proc_res = NULL;
    adegamma_proc_int->calib = sharedCom->calib;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "adegamma algo processing failed");

    comb->adegamma_proc_res = (RkAiqAlgoProcResAdegamma*)adegamma_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdegammaHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAdegammaInt* adegamma_post_int = (RkAiqAlgoPostAdegammaInt*)mPostInParam;
    RkAiqAlgoPostResAdegammaInt* adegamma_post_res_int = (RkAiqAlgoPostResAdegammaInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdegammaHandle::postProcess();
    if (ret) {
        comb->adegamma_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adegamma handle postProcess failed");
        return ret;
    }

    comb->adegamma_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "agamma algo post_process failed");
    // set result to mAiqCore
    comb->adegamma_post_res = (RkAiqAlgoPostResAdegamma*)adegamma_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAgicHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAgicHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAgicInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAgicInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAgicInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAgicInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAgicInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAgicInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAgicInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAgicHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_agic_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }
    if (needSync)
        mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAgicHandleInt::setAttrib(agic_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore
    if (0 != memcmp(&mCurAtt, &att, sizeof(agic_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAgicHandleInt::getAttrib(agic_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_agic_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAgicHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAgicHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "agic handle prepare failed");

    RkAiqAlgoConfigAgicInt* agic_config_int = (RkAiqAlgoConfigAgicInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "agic algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAgicHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAgicInt* agic_pre_int = (RkAiqAlgoPreAgicInt*)mPreInParam;
    RkAiqAlgoPreResAgicInt* agic_pre_res_int = (RkAiqAlgoPreResAgicInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAgicHandle::preProcess();
    if (ret) {
        comb->agic_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "agic handle preProcess failed");
    }

    comb->agic_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "agic algo pre_process failed");

    // set result to mAiqCore
    comb->agic_pre_res = (RkAiqAlgoPreResAgic*)agic_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAgicHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAgicInt* agic_proc_int = (RkAiqAlgoProcAgicInt*)mProcInParam;
    RkAiqAlgoProcResAgicInt* agic_proc_res_int = (RkAiqAlgoProcResAgicInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAgicHandle::processing();
    if (ret) {
        comb->agic_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "agic handle processing failed");
    }

    comb->agic_proc_res = NULL;
    agic_proc_int->hdr_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "agic algo processing failed");

    comb->agic_proc_res = (RkAiqAlgoProcResAgic*)agic_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAgicHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAgicInt* agic_post_int = (RkAiqAlgoPostAgicInt*)mPostInParam;
    RkAiqAlgoPostResAgicInt* agic_post_res_int = (RkAiqAlgoPostResAgicInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAgicHandle::postProcess();
    if (ret) {
        comb->agic_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "agic handle postProcess failed");
        return ret;
    }

    comb->agic_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "agic algo post_process failed");
    // set result to mAiqCore
    comb->agic_post_res = (RkAiqAlgoPostResAgic*)agic_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAieHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_aie_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }
    if (needSync)
        mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAieHandleInt::setAttrib(aie_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore
    if (0 != memcmp(&mCurAtt, &att, sizeof(aie_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAieHandleInt::getAttrib(aie_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_aie_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAieHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAieHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAieInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAieInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAieInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAieInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAieInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAieInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAieInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAieHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAieHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "aie handle prepare failed");

    RkAiqAlgoConfigAieInt* aie_config_int = (RkAiqAlgoConfigAieInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "aie algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAieHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAieInt* aie_pre_int = (RkAiqAlgoPreAieInt*)mPreInParam;
    RkAiqAlgoPreResAieInt* aie_pre_res_int = (RkAiqAlgoPreResAieInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAieHandle::preProcess();
    if (ret) {
        comb->aie_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aie handle preProcess failed");
    }

    comb->aie_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "aie algo pre_process failed");

    // set result to mAiqCore
    comb->aie_pre_res = (RkAiqAlgoPreResAie*)aie_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAieHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAieInt* aie_proc_int = (RkAiqAlgoProcAieInt*)mProcInParam;
    RkAiqAlgoProcResAieInt* aie_proc_res_int = (RkAiqAlgoProcResAieInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAieHandle::processing();
    if (ret) {
        comb->aie_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aie handle processing failed");
    }

    comb->aie_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "aie algo processing failed");

    comb->aie_proc_res = (RkAiqAlgoProcResAie*)aie_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAieHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAieInt* aie_post_int = (RkAiqAlgoPostAieInt*)mPostInParam;
    RkAiqAlgoPostResAieInt* aie_post_res_int = (RkAiqAlgoPostResAieInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAieHandle::postProcess();
    if (ret) {
        comb->aie_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aie handle postProcess failed");
        return ret;
    }

    comb->aie_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "aie algo post_process failed");
    // set result to mAiqCore
    comb->aie_post_res = (RkAiqAlgoPostResAie*)aie_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAldchHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAldchHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAldchInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAldchInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAldchInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAldchInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAldchInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAldchInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAldchInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAldchHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAldchHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "aldch handle prepare failed");

    RkAiqAlgoConfigAldchInt* aldch_config_int = (RkAiqAlgoConfigAldchInt*)mConfig;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    // memcpy(&aldch_config_int->aldch_calib_cfg, &shared->calib->aldch, sizeof(CalibDb_LDCH_t));
    aldch_config_int->resource_path = sharedCom->resourcePath;
    aldch_config_int->mem_ops_ptr = mAiqCore->mShareMemOps;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "aldch algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAldchHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAldchInt* aldch_pre_int = (RkAiqAlgoPreAldchInt*)mPreInParam;
    RkAiqAlgoPreResAldchInt* aldch_pre_res_int = (RkAiqAlgoPreResAldchInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAldchHandle::preProcess();
    if (ret) {
        comb->aldch_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aldch handle preProcess failed");
    }

    comb->aldch_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "aldch algo pre_process failed");

    // set result to mAiqCore
    comb->aldch_pre_res = (RkAiqAlgoPreResAldch*)aldch_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAldchHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAldchInt* aldch_proc_int = (RkAiqAlgoProcAldchInt*)mProcInParam;
    RkAiqAlgoProcResAldchInt* aldch_proc_res_int = (RkAiqAlgoProcResAldchInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAldchHandle::processing();
    if (ret) {
        comb->aldch_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aldch handle processing failed");
    }

    comb->aldch_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "aldch algo processing failed");

    comb->aldch_proc_res = (RkAiqAlgoProcResAldch*)aldch_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAldchHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAldchInt* aldch_post_int = (RkAiqAlgoPostAldchInt*)mPostInParam;
    RkAiqAlgoPostResAldchInt* aldch_post_res_int = (RkAiqAlgoPostResAldchInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAldchHandle::postProcess();
    if (ret) {
        comb->aldch_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aldch handle postProcess failed");
        return ret;
    }

    comb->aldch_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "aldch algo post_process failed");
    // set result to mAiqCore
    comb->aldch_post_res = (RkAiqAlgoPostResAldch*)aldch_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAldchHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_aldch_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAldchHandleInt::setAttrib(rk_aiq_ldch_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be efldchtive later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_ldch_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAldchHandleInt::getAttrib(rk_aiq_ldch_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_aldch_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAlscHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAlscHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAlscInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAlscInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAlscInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAlscInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAlscInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAlscInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAlscInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAlscHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_alsc_SetAttrib(mAlgoCtx, mCurAtt, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAlscHandleInt::setAttrib(rk_aiq_lsc_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_lsc_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAlscHandleInt::getAttrib(rk_aiq_lsc_attrib_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_alsc_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAlscHandleInt::queryLscInfo(rk_aiq_lsc_querry_info_t *lsc_querry_info )
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_alsc_QueryLscInfo(mAlgoCtx, lsc_querry_info);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAlscHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAlscHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "alsc handle prepare failed");

    RkAiqAlgoConfigAlscInt* alsc_config_int = (RkAiqAlgoConfigAlscInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "alsc algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAlscHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAlscInt* alsc_pre_int = (RkAiqAlgoPreAlscInt*)mPreInParam;
    RkAiqAlgoPreResAlscInt* alsc_pre_res_int = (RkAiqAlgoPreResAlscInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAlscHandle::preProcess();
    if (ret) {
        comb->alsc_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "alsc handle preProcess failed");
    }

    comb->alsc_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "alsc algo pre_process failed");

    // set result to mAiqCore
    comb->alsc_pre_res = (RkAiqAlgoPreResAlsc*)alsc_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAlscHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAlscInt* alsc_proc_int = (RkAiqAlgoProcAlscInt*)mProcInParam;
    RkAiqAlgoProcResAlscInt* alsc_proc_res_int = (RkAiqAlgoProcResAlscInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAlscHandle::processing();
    if (ret) {
        comb->alsc_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "alsc handle processing failed");
    }

    comb->alsc_proc_res = NULL;

    // TODO should check if the rk awb algo used
#if 0
    RkAiqAlgoProcResAwb* awb_res =
        (RkAiqAlgoProcResAwb*)(shared->procResComb.awb_proc_res);
    RkAiqAlgoProcResAwbInt* awb_res_int =
        (RkAiqAlgoProcResAwbInt*)(shared->procResComb.awb_proc_res);
    if(awb_res) {
        if(awb_res->awb_gain_algo.grgain < DIVMIN ||
                awb_res->awb_gain_algo.gbgain < DIVMIN ) {
            LOGE("get wrong awb gain from AWB module ,use default value ");
        } else {
            alsc_proc_int->alsc_sw_info.awbGain[0] =
                awb_res->awb_gain_algo.rgain / awb_res->awb_gain_algo.grgain;

            alsc_proc_int->alsc_sw_info.awbGain[1] =
                awb_res->awb_gain_algo.bgain / awb_res->awb_gain_algo.gbgain;
        }
        alsc_proc_int->alsc_sw_info.awbIIRDampCoef = awb_res_int->awb_smooth_factor;
        alsc_proc_int->alsc_sw_info.varianceLuma = awb_res_int->varianceLuma;
        alsc_proc_int->alsc_sw_info.awbConverged = awb_res_int->awbConverged;
    } else {
        LOGE("fail to get awb gain form AWB module,use default value ");
    }
    RkAiqAlgoPreResAeInt *ae_int = (RkAiqAlgoPreResAeInt*)shared->preResComb.ae_pre_res;
    if( ae_int) {
        if((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
            alsc_proc_int->alsc_sw_info.sensorGain = ae_int->ae_pre_res_rk.LinearExp.exp_real_params.analog_gain
                    * ae_int->ae_pre_res_rk.LinearExp.exp_real_params.digital_gain
                    * ae_int->ae_pre_res_rk.LinearExp.exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("sensor gain choose from second hdr frame for alsc");
            alsc_proc_int->alsc_sw_info.sensorGain = ae_int->ae_pre_res_rk.HdrExp[1].exp_real_params.analog_gain
                    * ae_int->ae_pre_res_rk.HdrExp[1].exp_real_params.digital_gain
                    * ae_int->ae_pre_res_rk.HdrExp[1].exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("sensor gain choose from third hdr frame for alsc");
            alsc_proc_int->alsc_sw_info.sensorGain = ae_int->ae_pre_res_rk.HdrExp[2].exp_real_params.analog_gain
                    * ae_int->ae_pre_res_rk.HdrExp[2].exp_real_params.digital_gain
                    * ae_int->ae_pre_res_rk.HdrExp[2].exp_real_params.isp_dgain;
        } else {
            LOGE("working_mode (%d) is invaild ,fail to get sensor gain form AE module,use default value ",
                 sharedCom->working_mode);
        }
    } else {
        LOGE("fail to get sensor gain form AE module,use default value ");
    }
#else
    alsc_proc_int->tx = shared->tx;
    XCamVideoBuffer* awb_proc_res = shared->res_comb.awb_proc_res;
    if (awb_proc_res) {
        RkAiqAlgoProcResAwbInt* awb_res_int = (RkAiqAlgoProcResAwbInt*)awb_proc_res->map(awb_proc_res);
        RkAiqAlgoProcResAwb* awb_res = &awb_res_int->awb_proc_res_com;
        if(awb_res) {
            if(awb_res->awb_gain_algo.grgain < DIVMIN ||
                    awb_res->awb_gain_algo.gbgain < DIVMIN ) {
                LOGE("get wrong awb gain from AWB module ,use default value ");
            } else {
                alsc_proc_int->alsc_sw_info.awbGain[0] =
                    awb_res->awb_gain_algo.rgain / awb_res->awb_gain_algo.grgain;

                alsc_proc_int->alsc_sw_info.awbGain[1] =
                    awb_res->awb_gain_algo.bgain / awb_res->awb_gain_algo.gbgain;
            }
            alsc_proc_int->alsc_sw_info.awbIIRDampCoef = awb_res_int->awb_smooth_factor;
            alsc_proc_int->alsc_sw_info.varianceLuma = awb_res_int->varianceLuma;
            alsc_proc_int->alsc_sw_info.awbConverged = awb_res_int->awbConverged;
        } else {
            LOGE("fail to get awb gain form AWB module,use default value ");
        }
    } else {
        LOGE("fail to get awb gain form AWB module,use default value ");
    }

    RKAiqAecExpInfo_t *pCurExp = &shared->curExp;
    if(pCurExp) {
        if((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
            alsc_proc_int->alsc_sw_info.sensorGain = pCurExp->LinearExp.exp_real_params.analog_gain
                    * pCurExp->LinearExp.exp_real_params.digital_gain
                    * pCurExp->LinearExp.exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("sensor gain choose from second hdr frame for alsc");
            alsc_proc_int->alsc_sw_info.sensorGain = pCurExp->HdrExp[1].exp_real_params.analog_gain
                    * pCurExp->HdrExp[1].exp_real_params.digital_gain
                    * pCurExp->HdrExp[1].exp_real_params.isp_dgain;
        } else if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2
                  && (rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR3)  {
            LOGD("sensor gain choose from third hdr frame for alsc");
            alsc_proc_int->alsc_sw_info.sensorGain = pCurExp->HdrExp[2].exp_real_params.analog_gain
                    * pCurExp->HdrExp[2].exp_real_params.digital_gain
                    * pCurExp->HdrExp[2].exp_real_params.isp_dgain;
        } else {
            LOGE("working_mode (%d) is invaild ,fail to get sensor gain form AE module,use default value ",
                 sharedCom->working_mode);
        }
    } else {
        LOGE("fail to get sensor gain form AE module,use default value ");
    }
#endif

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "alsc algo processing failed");

    comb->alsc_proc_res = (RkAiqAlgoProcResAlsc*)alsc_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAlscHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAlscInt* alsc_post_int = (RkAiqAlgoPostAlscInt*)mPostInParam;
    RkAiqAlgoPostResAlscInt* alsc_post_res_int = (RkAiqAlgoPostResAlscInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAlscHandle::postProcess();
    if (ret) {
        comb->alsc_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "alsc handle postProcess failed");
        return ret;
    }

    comb->alsc_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "alsc algo post_process failed");
    // set result to mAiqCore
    comb->alsc_post_res = (RkAiqAlgoPostResAlsc*)alsc_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAr2yHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAr2yHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAr2yInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAr2yInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAr2yInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAr2yInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAr2yInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAr2yInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAr2yInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAr2yHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAr2yHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "ar2y handle prepare failed");

    RkAiqAlgoConfigAr2yInt* ar2y_config_int = (RkAiqAlgoConfigAr2yInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "ar2y algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAr2yHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAr2yInt* ar2y_pre_int = (RkAiqAlgoPreAr2yInt*)mPreInParam;
    RkAiqAlgoPreResAr2yInt* ar2y_pre_res_int = (RkAiqAlgoPreResAr2yInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAr2yHandle::preProcess();
    if (ret) {
        comb->ar2y_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ar2y handle preProcess failed");
    }

    comb->ar2y_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "ar2y algo pre_process failed");

    // set result to mAiqCore
    comb->ar2y_pre_res = (RkAiqAlgoPreResAr2y*)ar2y_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAr2yHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAr2yInt* ar2y_proc_int = (RkAiqAlgoProcAr2yInt*)mProcInParam;
    RkAiqAlgoProcResAr2yInt* ar2y_proc_res_int = (RkAiqAlgoProcResAr2yInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAr2yHandle::processing();
    if (ret) {
        comb->ar2y_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ar2y handle processing failed");
    }

    comb->ar2y_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "ar2y algo processing failed");

    comb->ar2y_proc_res = (RkAiqAlgoProcResAr2y*)ar2y_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAr2yHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAr2yInt* ar2y_post_int = (RkAiqAlgoPostAr2yInt*)mPostInParam;
    RkAiqAlgoPostResAr2yInt* ar2y_post_res_int = (RkAiqAlgoPostResAr2yInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAr2yHandle::postProcess();
    if (ret) {
        comb->ar2y_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "ar2y handle postProcess failed");
        return ret;
    }

    comb->ar2y_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "ar2y algo post_process failed");
    // set result to mAiqCore
    comb->ar2y_post_res = (RkAiqAlgoPostResAr2y*)ar2y_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwdrHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAwdrHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "awdr handle prepare failed");

    RkAiqAlgoConfigAwdrInt* awdr_config_int = (RkAiqAlgoConfigAwdrInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "awdr algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

void
RkAiqAwdrHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAwdrHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAwdrInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAwdrInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAwdrInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAwdrInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAwdrInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAwdrInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAwdrInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAwdrHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAwdrInt* awdr_pre_int = (RkAiqAlgoPreAwdrInt*)mPreInParam;
    RkAiqAlgoPreResAwdrInt* awdr_pre_res_int = (RkAiqAlgoPreResAwdrInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAwdrHandle::preProcess();
    if (ret) {
        comb->awdr_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "awdr handle preProcess failed");
    }

    comb->awdr_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "awdr algo pre_process failed");

    // set result to mAiqCore
    comb->awdr_pre_res = (RkAiqAlgoPreResAwdr*)awdr_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAwdrHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAwdrInt* awdr_proc_int = (RkAiqAlgoProcAwdrInt*)mProcInParam;
    RkAiqAlgoProcResAwdrInt* awdr_proc_res_int = (RkAiqAlgoProcResAwdrInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAwdrHandle::processing();
    if (ret) {
        comb->awdr_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "awdr handle processing failed");
    }

    comb->awdr_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "awdr algo processing failed");

    comb->awdr_proc_res = (RkAiqAlgoProcResAwdr*)awdr_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAwdrHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAwdrInt* awdr_post_int = (RkAiqAlgoPostAwdrInt*)mPostInParam;
    RkAiqAlgoPostResAwdrInt* awdr_post_res_int = (RkAiqAlgoPostResAwdrInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAwdrHandle::postProcess();
    if (ret) {
        comb->awdr_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "awdr handle postProcess failed");
        return ret;
    }

    comb->awdr_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "awdr algo post_process failed");
    // set result to mAiqCore
    comb->awdr_post_res = (RkAiqAlgoPostResAwdr*)awdr_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAdrcHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAdrcHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "adrc handle prepare failed");

    RkAiqAlgoConfigAdrcInt* adrc_config_int = (RkAiqAlgoConfigAdrcInt*)mConfig;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    adrc_config_int->rawHeight = sharedCom->snsDes.isp_acq_height;
    adrc_config_int->rawWidth = sharedCom->snsDes.isp_acq_width;
    adrc_config_int->working_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "adrc algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

void
RkAiqAdrcHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAdrcHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAdrcInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAdrcInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAdrcInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAdrcInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAdrcInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAdrcInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAdrcInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAdrcHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_adrc_SetAttrib(mAlgoCtx, mCurAtt, true);
        sendSignal();
    }
    if (needSync)
        mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdrcHandleInt::setAttrib(drc_attrib_t att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, &att, sizeof(drc_attrib_t))) {
        mNewAtt = att;
        updateAtt = true;
        waitSignal();
    }
    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}
XCamReturn
RkAiqAdrcHandleInt::getAttrib(drc_attrib_t* att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_adrc_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdrcHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAdrcInt* adrc_pre_int = (RkAiqAlgoPreAdrcInt*)mPreInParam;
    RkAiqAlgoPreResAdrcInt* adrc_pre_res_int = (RkAiqAlgoPreResAdrcInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdrcHandle::preProcess();
    if (ret) {
        comb->adrc_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adrc handle preProcess failed");
    }

    comb->adrc_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "adrc algo pre_process failed");

    // set result to mAiqCore
    comb->adrc_pre_res = (RkAiqAlgoPreResAdrc*)adrc_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAdrcHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAdrcInt* adrc_proc_int = (RkAiqAlgoProcAdrcInt*)mProcInParam;
    RkAiqAlgoProcResAdrcInt* adrc_proc_res_int = (RkAiqAlgoProcResAdrcInt*)mProcOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdrcHandle::processing();
    if (ret) {
        comb->adrc_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adrc handle processing failed");
    }

    comb->adrc_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "adrc algo processing failed");

    comb->adrc_proc_res = (RkAiqAlgoProcResAdrc*)adrc_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAdrcHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAdrcInt* adrc_post_int = (RkAiqAlgoPostAdrcInt*)mPostInParam;
    RkAiqAlgoPostResAdrcInt* adrc_post_res_int = (RkAiqAlgoPostResAdrcInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAdrcHandle::postProcess();
    if (ret) {
        comb->adrc_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "adrc handle postProcess failed");
        return ret;
    }

    comb->adrc_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "adrc algo post_process failed");
    // set result to mAiqCore
    comb->adrc_post_res = (RkAiqAlgoPostResAdrc*)adrc_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmdHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAmdHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "amd handle prepare failed");

    RkAiqAlgoConfigAmdInt* amd_config_int = (RkAiqAlgoConfigAmdInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    amd_config_int->amd_config_com.spWidth = sharedCom->spWidth;
    amd_config_int->amd_config_com.spHeight = sharedCom->spHeight;
    amd_config_int->amd_config_com.spAlignedW = sharedCom->spAlignedWidth;
    amd_config_int->amd_config_com.spAlignedH = sharedCom->spAlignedHeight;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "amd algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

void
RkAiqAmdHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAmdHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAmdInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAmdInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAmdInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAmdInt());
    // mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAmdInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAmdInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAmdInt());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn
RkAiqAmdHandleInt::updateConfig(bool needSync)
{
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAmdHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAmdInt* amd_pre_int = (RkAiqAlgoPreAmdInt*)mPreInParam;
    RkAiqAlgoPreResAmdInt* amd_pre_res_int = (RkAiqAlgoPreResAmdInt*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAmdHandle::preProcess();
    if (ret) {
        comb->amd_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "amd handle preProcess failed");
    }

    comb->amd_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "amd algo pre_process failed");

    // set result to mAiqCore
    comb->amd_pre_res = (RkAiqAlgoPreResAmd*)amd_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAmdHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAmdInt* amd_proc_int = (RkAiqAlgoProcAmdInt*)mProcInParam;

    mProcResShared = new RkAiqAlgoProcResAmdIntShared();
    if (!mProcResShared.ptr()) {
        LOGE("new amd mProcOutParam failed, bypass!");
        return XCAM_RETURN_BYPASS;
    }
    RkAiqAlgoProcResAmdInt* amd_proc_res_int = &mProcResShared->result;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAmdHandle::processing();
    if (ret) {
        comb->amd_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "amd handle processing failed");
    }

    comb->amd_proc_res = NULL;
    memset(&amd_proc_res_int->amd_proc_res_com.amd_proc_res, 0, sizeof(amd_proc_res_int->amd_proc_res_com.amd_proc_res));
    amd_proc_int->stats.spImage = shared->sp;
    amd_proc_int->stats.ispGain = shared->ispGain;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)amd_proc_res_int);
    RKAIQCORE_CHECK_RET(ret, "amd algo processing failed");

    comb->amd_proc_res = (RkAiqAlgoProcResAmd*)amd_proc_res_int;

    MediaBuffer_t *mbuf = amd_proc_res_int->amd_proc_res_com.amd_proc_res.st_ratio;
    if (mbuf) {
        MotionBufMetaData_t *metadata = (MotionBufMetaData_t *)mbuf->pMetaData;
        SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AMD_PROC_RES_OK,
                metadata->frame_id,
                mProcResShared);
        mAiqCore->post_message(msg);
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmdHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAmdInt* amd_post_int = (RkAiqAlgoPostAmdInt*)mPostInParam;
    RkAiqAlgoPostResAmdInt* amd_post_res_int = (RkAiqAlgoPostResAmdInt*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    ret = RkAiqAmdHandle::postProcess();
    if (ret) {
        comb->amd_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "amd handle postProcess failed");
        return ret;
    }

    comb->amd_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "amd algo post_process failed");
    // set result to mAiqCore
    comb->amd_post_res = (RkAiqAlgoPostResAmd*)amd_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqArawnrHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqArawnrHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigArawnrInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreArawnrInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResArawnrInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcArawnrInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResArawnrInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostArawnrInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResArawnrInt());

    EXIT_ANALYZER_FUNCTION();
}


XCamReturn
RkAiqArawnrHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        rk_aiq_uapi_abayernr_SetAttrib_v1(mAlgoCtx, &mCurAtt, false);
        sendSignal();
    }

    if(updateIQpara) {
        mCurIQPara = mNewIQPara;
        updateIQpara = false;
        // TODO
        rk_aiq_uapi_abayernr_SetIQPara_v1(mAlgoCtx, &mCurIQPara, false);
        sendSignal();
    }

    if(updateJsonpara) {
        mCurJsonPara = mNewJsonPara;
        updateJsonpara = false;
        // TODO
        rk_aiq_uapi_abayernr_SetJsonPara_v1(mAlgoCtx, &mCurJsonPara, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqArawnrHandleInt::setAttrib(rk_aiq_bayernr_attrib_v1_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_bayernr_attrib_v1_t))) {
        mNewAtt = *att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqArawnrHandleInt::getAttrib(rk_aiq_bayernr_attrib_v1_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_abayernr_GetAttrib_v1(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqArawnrHandleInt::setIQPara(rk_aiq_bayernr_IQPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_bayernr_IQPara_V1_t))) {
        mNewIQPara = *para;
        updateIQpara = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqArawnrHandleInt::getIQPara(rk_aiq_bayernr_IQPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    printf("rawnr get iq para enter\n");
    rk_aiq_uapi_abayernr_GetIQPara_v1(mAlgoCtx, para);
    printf("rawnr get iq para exit\n");

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqArawnrHandleInt::setJsonPara(rk_aiq_bayernr_JsonPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_bayernr_JsonPara_V1_t))) {
        mNewJsonPara = *para;
        updateJsonpara = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqArawnrHandleInt::getJsonPara(rk_aiq_bayernr_JsonPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_abayernr_GetJsonPara_v1(mAlgoCtx, para);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}



XCamReturn
RkAiqArawnrHandleInt::setStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_abayernr_SetRawnrSFStrength_v1(mAlgoCtx, fPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqArawnrHandleInt::getStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_abayernr_GetRawnrSFStrength_v1(mAlgoCtx, pPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqArawnrHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqArawnrHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "arawnr handle prepare failed");

    RkAiqAlgoConfigArawnrInt* aynr_config_int = (RkAiqAlgoConfigArawnrInt*)mConfig;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "arawnr algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqArawnrHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreArawnrInt* arawnr_pre_int = (RkAiqAlgoPreArawnrInt*)mPreInParam;
    RkAiqAlgoPreResArawnrInt* arawnr_pre_res_int = (RkAiqAlgoPreResArawnrInt*)mPreOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;


    ret = RkAiqArawnrHandle::preProcess();
    if (ret) {
        comb->arawnr_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "arawnr handle preProcess failed");
    }

    comb->arawnr_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "arawnr algo pre_process failed");
    // set result to mAiqCore
    comb->arawnr_pre_res = (RkAiqAlgoPreResArawnr*)arawnr_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqArawnrHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcArawnrInt* arawnr_proc_int = (RkAiqAlgoProcArawnrInt*)mProcInParam;
    RkAiqAlgoProcResArawnrInt* arawnr_proc_res_int = (RkAiqAlgoProcResArawnrInt*)mProcOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    static int arawnr_proc_framecnt = 0;
    arawnr_proc_framecnt++;

    ret = RkAiqArawnrHandle::processing();
    if (ret) {
        comb->arawnr_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aynr handle processing failed");
    }

    comb->arawnr_proc_res = NULL;

    // TODO: fill procParam
    arawnr_proc_int->iso = sharedCom->iso;
    arawnr_proc_int->hdr_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");

    comb->arawnr_proc_res = (RkAiqAlgoProcResArawnr*)arawnr_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqArawnrHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostArawnrInt* arawnr_post_int = (RkAiqAlgoPostArawnrInt*)mPostInParam;
    RkAiqAlgoPostResArawnrInt* arawnr_post_res_int = (RkAiqAlgoPostResArawnrInt*)mPostOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqArawnrHandle::postProcess();
    if (ret) {
        comb->aynr_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "arawnr handle postProcess failed");
        return ret;
    }

    comb->aynr_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "arawnr algo post_process failed");
    // set result to mAiqCore
    comb->arawnr_post_res = (RkAiqAlgoPostResArawnr*)arawnr_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAynrHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAynrHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAynrInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAynrInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAynrInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAynrInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAynrInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAynrInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAynrInt());

    EXIT_ANALYZER_FUNCTION();
}


XCamReturn
RkAiqAynrHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_aynr_SetAttrib_v1(mAlgoCtx, &mCurAtt, false);
        sendSignal();
    }

    if(updateIQpara) {
        mCurIQPara = mNewIQPara;
        updateIQpara = false;
        // TODO
        rk_aiq_uapi_aynr_SetIQPara_v1(mAlgoCtx, &mCurIQPara, false);
        sendSignal();
    }

    if(updateJsonpara) {
        mCurJsonPara = mNewJsonPara;
        updateJsonpara = false;
        // TODO
        rk_aiq_uapi_aynr_SetJsonPara_v1(mAlgoCtx, &mCurJsonPara, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAynrHandleInt::setAttrib(rk_aiq_ynr_attrib_v1_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_ynr_attrib_v1_t))) {
        mNewAtt = *att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAynrHandleInt::getAttrib(rk_aiq_ynr_attrib_v1_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_aynr_GetAttrib_v1(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAynrHandleInt::setIQPara(rk_aiq_ynr_IQPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_ynr_IQPara_V1_t))) {
        mNewIQPara = *para;
        updateIQpara = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAynrHandleInt::getIQPara(rk_aiq_ynr_IQPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_aynr_GetIQPara_v1(mAlgoCtx, para);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAynrHandleInt::setJsonPara(rk_aiq_ynr_JsonPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_ynr_JsonPara_V1_t))) {
        mNewJsonPara = *para;
        updateJsonpara = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAynrHandleInt::getJsonPara(rk_aiq_ynr_JsonPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_aynr_GetJsonPara_v1(mAlgoCtx, para);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAynrHandleInt::setStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_aynr_SetLumaSFStrength_v1(mAlgoCtx, fPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAynrHandleInt::getStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_aynr_GetLumaSFStrength_v1(mAlgoCtx, pPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAynrHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAynrHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "aynr handle prepare failed");

    RkAiqAlgoConfigAynrInt* aynr_config_int = (RkAiqAlgoConfigAynrInt*)mConfig;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "aynr algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAynrHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAynrInt* aynr_pre_int = (RkAiqAlgoPreAynrInt*)mPreInParam;
    RkAiqAlgoPreResAynrInt* aynr_pre_res_int = (RkAiqAlgoPreResAynrInt*)mPreOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAynrHandle::preProcess();
    if (ret) {
        comb->aynr_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aynr handle preProcess failed");
    }

    comb->aynr_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "aynr algo pre_process failed");
    // set result to mAiqCore
    comb->aynr_pre_res = (RkAiqAlgoPreResAynr*)aynr_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAynrHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAynrInt* aynr_proc_int = (RkAiqAlgoProcAynrInt*)mProcInParam;
    RkAiqAlgoProcResAynrInt* aynr_proc_res_int = (RkAiqAlgoProcResAynrInt*)mProcOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    static int aynr_proc_framecnt = 0;
    aynr_proc_framecnt++;

    ret = RkAiqAynrHandle::processing();
    if (ret) {
        comb->aynr_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aynr handle processing failed");
    }

    comb->aynr_proc_res = NULL;

    // TODO: fill procParam
    aynr_proc_int->iso = sharedCom->iso;
    aynr_proc_int->hdr_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");

    comb->aynr_proc_res = (RkAiqAlgoProcResAynr*)aynr_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAynrHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAynrInt* aynr_post_int = (RkAiqAlgoPostAynrInt*)mPostInParam;
    RkAiqAlgoPostResAynrInt* aynr_post_res_int = (RkAiqAlgoPostResAynrInt*)mPostOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAynrHandle::postProcess();
    if (ret) {
        comb->aynr_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "aynr handle postProcess failed");
        return ret;
    }

    comb->aynr_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "aynr algo post_process failed");
    // set result to mAiqCore
    comb->aynr_post_res = (RkAiqAlgoPostResAynr*)aynr_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

//uvnr
void
RkAiqAcnrHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAcnrHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAcnrInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAcnrInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAcnrInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAcnrInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAcnrInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAcnrInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAcnrInt());

    EXIT_ANALYZER_FUNCTION();
}


XCamReturn
RkAiqAcnrHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_auvnr_SetAttrib(mAlgoCtx, &mCurAtt, false);
        sendSignal();
    }

    if(updateIQpara) {
        mCurIQPara = mNewIQPara;
        updateIQpara = false;
        // TODO
        rk_aiq_uapi_auvnr_SetIQPara(mAlgoCtx, &mCurIQPara, false);
        sendSignal();
    }

    if(updateJsonpara) {
        mCurJsonPara = mNewJsonPara;
        updateJsonpara = false;
        // TODO
        rk_aiq_uapi_auvnr_SetJsonPara(mAlgoCtx, &mCurJsonPara, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcnrHandleInt::setAttrib(rk_aiq_uvnr_attrib_v1_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_uvnr_attrib_v1_t))) {
        mNewAtt = *att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcnrHandleInt::getAttrib(rk_aiq_uvnr_attrib_v1_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_auvnr_GetAttrib(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcnrHandleInt::setIQPara(rk_aiq_uvnr_IQPara_v1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_uvnr_IQPara_v1_t))) {
        mNewIQPara = *para;
        updateIQpara = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcnrHandleInt::getIQPara(rk_aiq_uvnr_IQPara_v1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_auvnr_GetIQPara(mAlgoCtx, para);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcnrHandleInt::setJsonPara(rk_aiq_uvnr_JsonPara_v1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_uvnr_JsonPara_v1_t))) {
        mNewJsonPara = *para;
        updateJsonpara = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcnrHandleInt::getJsonPara(rk_aiq_uvnr_JsonPara_v1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_auvnr_GetJsonPara(mAlgoCtx, para);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}



XCamReturn
RkAiqAcnrHandleInt::setStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    //rk_aiq_uapi_asharp_SetStrength(mAlgoCtx, fPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAcnrHandleInt::getStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    //rk_aiq_uapi_asharp_GetStrength(mAlgoCtx, pPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAcnrHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAcnrHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "auvnr handle prepare failed");

    RkAiqAlgoConfigAcnrInt* auvnr_config_int = (RkAiqAlgoConfigAcnrInt*)mConfig;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "auvnr algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAcnrHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAcnrInt* auvnr_pre_int = (RkAiqAlgoPreAcnrInt*)mPreInParam;
    RkAiqAlgoPreResAcnrInt* auvnr_pre_res_int = (RkAiqAlgoPreResAcnrInt*)mPreOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;


    ret = RkAiqAcnrHandle::preProcess();
    if (ret) {
        comb->acnr_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "auvnr handle preProcess failed");
    }

    comb->acnr_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "auvnr algo pre_process failed");
    // set result to mAiqCore
    comb->acnr_pre_res = (RkAiqAlgoPreResAcnr*)auvnr_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAcnrHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAcnrInt* auvnr_proc_int = (RkAiqAlgoProcAcnrInt*)mProcInParam;
    RkAiqAlgoProcResAcnrInt* auvnr_proc_res_int = (RkAiqAlgoProcResAcnrInt*)mProcOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    static int auvnr_proc_framecnt = 0;
    auvnr_proc_framecnt++;

    ret = RkAiqAcnrHandle::processing();
    if (ret) {
        comb->acnr_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "auvnr handle processing failed");
    }

    comb->acnr_proc_res = NULL;

    // TODO: fill procParam
    auvnr_proc_int->iso = sharedCom->iso;
    auvnr_proc_int->hdr_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");

    comb->acnr_proc_res = (RkAiqAlgoProcResAcnr*)auvnr_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAcnrHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAcnrInt* auvnr_post_int = (RkAiqAlgoPostAcnrInt*)mPostInParam;
    RkAiqAlgoPostResAcnrInt* auvnr_post_res_int = (RkAiqAlgoPostResAcnrInt*)mPostOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAcnrHandle::postProcess();
    if (ret) {
        comb->acnr_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "auvnr handle postProcess failed");
        return ret;
    }

    comb->acnr_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "auvnr algo post_process failed");
    // set result to mAiqCore
    comb->acnr_post_res = (RkAiqAlgoPostResAcnr*)auvnr_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAmfnrHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAmfnrHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAmfnrInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAmfnrInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAmfnrInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAmfnrInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAmfnrInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAmfnrInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAmfnrInt());

    EXIT_ANALYZER_FUNCTION();
}



XCamReturn
RkAiqAmfnrHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();
    // if something changed
    if (updateAtt) {
        mCurAtt = mNewAtt;
        updateAtt = false;
        // TODO
        rk_aiq_uapi_amfnr_SetAttrib_v1(mAlgoCtx, &mCurAtt, false);
        sendSignal();
    }

    if(updateIQpara) {
        mCurIQPara = mNewIQPara;
        updateIQpara = false;
        // TODO
        rk_aiq_uapi_amfnr_SetIQPara_v1(mAlgoCtx, &mCurIQPara, false);
        sendSignal();
    }

    if(updateJsonpara) {
        mCurJsonPara = mNewJsonPara;
        updateJsonpara = false;
        // TODO
        rk_aiq_uapi_amfnr_SetJsonPara_v1(mAlgoCtx, &mCurJsonPara, false);
        sendSignal();
    }

    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAmfnrHandleInt::setAttrib(rk_aiq_mfnr_attrib_v1_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_mfnr_attrib_v1_t))) {
        mNewAtt = *att;
        updateAtt = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmfnrHandleInt::getAttrib(rk_aiq_mfnr_attrib_v1_t *att)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_amfnr_GetAttrib_v1(mAlgoCtx, att);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmfnrHandleInt::setIQPara(rk_aiq_mfnr_IQPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_mfnr_IQPara_V1_t))) {
        mNewIQPara = *para;
        updateIQpara = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmfnrHandleInt::getIQPara(rk_aiq_mfnr_IQPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_amfnr_GetIQPara_v1(mAlgoCtx, para);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmfnrHandleInt::setJsonPara(rk_aiq_mfnr_JsonPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    mCfgMutex.lock();
    //TODO
    // check if there is different between att & mCurAtt
    // if something changed, set att to mNewAtt, and
    // the new params will be effective later when updateConfig
    // called by RkAiqCore

    // if something changed
    if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_mfnr_JsonPara_V1_t))) {
        mNewJsonPara = *para;
        updateJsonpara = true;
        waitSignal();
    }

    mCfgMutex.unlock();

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmfnrHandleInt::getJsonPara(rk_aiq_mfnr_JsonPara_V1_t *para)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_amfnr_GetJsonPara_v1(mAlgoCtx, para);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}



XCamReturn
RkAiqAmfnrHandleInt::setLumaStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_amfnr_SetLumaTFStrength_v1(mAlgoCtx, fPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAmfnrHandleInt::getLumaStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_amfnr_GetLumaTFStrength_v1(mAlgoCtx, pPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmfnrHandleInt::setChromaStrength(float fPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_amfnr_SetChromaTFStrength_v1(mAlgoCtx, fPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAmfnrHandleInt::getChromaStrength(float *pPercent)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_uapi_amfnr_GetChromaTFStrength_v1(mAlgoCtx, pPercent);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}



XCamReturn
RkAiqAmfnrHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAmfnrHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "amfnr handle prepare failed");

    RkAiqAlgoConfigAmfnrInt* amfnr_config_int = (RkAiqAlgoConfigAmfnrInt*)mConfig;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "amfnr algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
RkAiqAmfnrHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAmfnrInt* amfnr_pre_int = (RkAiqAlgoPreAmfnrInt*)mPreInParam;
    RkAiqAlgoPreResAmfnrInt* amfnr_pre_res_int = (RkAiqAlgoPreResAmfnrInt*)mPreOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAmfnrHandle::preProcess();
    if (ret) {
        comb->amfnr_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "amfnr handle preProcess failed");
    }

    comb->amfnr_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "amfnr algo pre_process failed");

    // set result to mAiqCore
    comb->amfnr_pre_res = (RkAiqAlgoPreResAmfnr*)amfnr_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAmfnrHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAmfnrInt* amfnr_proc_int = (RkAiqAlgoProcAmfnrInt*)mProcInParam;
    RkAiqAlgoProcResAmfnrInt* amfnr_proc_res_int = (RkAiqAlgoProcResAmfnrInt*)mProcOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAmfnrHandle::processing();
    if (ret) {
        comb->amfnr_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "amfnr handle processing failed");
    }

    comb->amfnr_proc_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "amfnr algo processing failed");

    comb->amfnr_proc_res = (RkAiqAlgoProcResAmfnr*)amfnr_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAmfnrHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAmfnrInt* amfnr_post_int = (RkAiqAlgoPostAmfnrInt*)mPostInParam;
    RkAiqAlgoPostResAmfnrInt* amfnr_post_res_int = (RkAiqAlgoPostResAmfnrInt*)mPostOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAmfnrHandle::postProcess();
    if (ret) {
        comb->amfnr_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "amfnr handle postProcess failed");
        return ret;
    }

    comb->amfnr_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "amfnr algo post_process failed");
    // set result to mAiqCore
    comb->amfnr_post_res = (RkAiqAlgoPostResAmfnr*)amfnr_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

void
RkAiqAgainHandleInt::init()
{
    ENTER_ANALYZER_FUNCTION();

    RkAiqAgainHandle::deInit();
    mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAgainInt());
    mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAgainInt());
    mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAgainInt());
    mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAgainInt());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAgainInt());
    mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAgainInt());
    mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAgainInt());

    EXIT_ANALYZER_FUNCTION();
}


XCamReturn
RkAiqAgainHandleInt::updateConfig(bool needSync)
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (needSync)
        mCfgMutex.lock();


    if (needSync)
        mCfgMutex.unlock();


    EXIT_ANALYZER_FUNCTION();
    return ret;
}


XCamReturn
RkAiqAgainHandleInt::prepare()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = RkAiqAgainHandle::prepare();
    RKAIQCORE_CHECK_RET(ret, "again handle prepare failed");

    RkAiqAlgoConfigAgainInt* again_config_int = (RkAiqAlgoConfigAgainInt*)mConfig;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->prepare(mConfig);
    RKAIQCORE_CHECK_RET(ret, "again algo prepare failed");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAgainHandleInt::preProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPreAgainInt* again_pre_int = (RkAiqAlgoPreAgainInt*)mPreInParam;
    RkAiqAlgoPreResAgainInt* again_pre_res_int = (RkAiqAlgoPreResAgainInt*)mPreOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPreResComb* comb = &shared->preResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;


    ret = RkAiqAgainHandle::preProcess();
    if (ret) {
        comb->again_pre_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "again handle preProcess failed");
    }

    comb->again_pre_res = NULL;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->pre_process(mPreInParam, mPreOutParam);
    RKAIQCORE_CHECK_RET(ret, "again algo pre_process failed");
    // set result to mAiqCore
    comb->again_pre_res = (RkAiqAlgoPreResAgain*)again_pre_res_int;

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
RkAiqAgainHandleInt::processing()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAgainInt* again_proc_int = (RkAiqAlgoProcAgainInt*)mProcInParam;
    RkAiqAlgoProcResAgainInt* again_proc_res_int = (RkAiqAlgoProcResAgainInt*)mProcOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqProcResComb* comb = &shared->procResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    static int auvnr_proc_framecnt = 0;
    auvnr_proc_framecnt++;

    ret = RkAiqAgainHandle::processing();
    if (ret) {
        comb->again_proc_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "again handle processing failed");
    }

    comb->again_proc_res = NULL;

    // TODO: fill procParam
    again_proc_int->iso = sharedCom->iso;
    again_proc_int->hdr_mode = sharedCom->working_mode;

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->processing(mProcInParam, mProcOutParam);
    RKAIQCORE_CHECK_RET(ret, "again algo processing failed");

    comb->again_proc_res = (RkAiqAlgoProcResAgain*)again_proc_res_int;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn
RkAiqAgainHandleInt::postProcess()
{
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAgainInt* again_post_int = (RkAiqAlgoPostAgainInt*)mPostInParam;
    RkAiqAlgoPostResAgainInt* again_post_res_int = (RkAiqAlgoPostResAgainInt*)mPostOutParam;

    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqPostResComb* comb = &shared->postResComb;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
    RkAiqIspStats* ispStats = shared->ispStats;

    ret = RkAiqAgainHandle::postProcess();
    if (ret) {
        comb->again_post_res = NULL;
        RKAIQCORE_CHECK_RET(ret, "auvnr handle postProcess failed");
        return ret;
    }

    comb->again_post_res = NULL;
    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "auvnr algo post_process failed");
    // set result to mAiqCore
    comb->again_post_res = (RkAiqAlgoPostResAgain*)again_post_res_int ;

    EXIT_ANALYZER_FUNCTION();
    return ret;
}


}; //namespace RkCam