/*
 * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
 *
 * 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 "RkAiqAfHandle.h"

#include "RkAiqCore.h"
#include "RkAiqAeHandle.h"

namespace RkCam {

DEFINE_HANDLE_REGISTER_TYPE(RkAiqAfHandleInt);

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

    RkAiqHandle::deInit();
    mConfig      = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAf());
    mPreInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPreAf());
    mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAf());
    mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAf());
#if 0
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAf());
#endif
    mPostInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPostAf());
    mPostOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAf());
    mLastZoomIndex = 0;

    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();

        // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
        // if something changed, set att to mNewAtt, and
        // the new params will be effective later when updateConfig
        // called by RkAiqCore
        bool isChanged = false;
        if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
            memcmp(&mNewAtt, att, sizeof(*att)))
            isChanged = true;
        else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
                 memcmp(&mCurAtt, att, sizeof(*att)))
            isChanged = true;

        // if something changed
        if (isChanged || (mCurAtt.AfMode == RKAIQ_AF_MODE_AUTO)) {
            mNewAtt         = *att;
            updateAtt       = true;
            isUpdateAttDone = false;
            waitSignal(att->sync.sync_mode);
        }

        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;

    if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
        mCfgMutex.lock();
        rk_aiq_uapi_af_GetAttrib(mAlgoCtx, att);
        att->sync.done = true;
        mCfgMutex.unlock();
    } else {
        if (updateAtt) {
            memcpy(att, &mNewAtt, sizeof(mNewAtt));
            att->sync.done = false;
        } else {
            rk_aiq_uapi_af_GetAttrib(mAlgoCtx, att);
            att->sync.sync_mode = mNewAtt.sync.sync_mode;
            att->sync.done      = true;
        }
    }

    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::setZoomIndex(int index) {
    ENTER_ANALYZER_FUNCTION();

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

    if (sharedCom->snsDes.lens_des.zoom_support) {
        mCfgMutex.lock();
        rk_aiq_uapi_af_setZoomIndex(mAlgoCtx, index);
        isUpdateZoomPosDone = true;
        waitSignal();
        mCfgMutex.unlock();
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn RkAiqAfHandleInt::getZoomIndex(int* index) {
    ENTER_ANALYZER_FUNCTION();

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

    if (sharedCom->snsDes.lens_des.zoom_support) {
        rk_aiq_uapi_af_getZoomIndex(mAlgoCtx, index);
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

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

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

    if (sharedCom->snsDes.lens_des.zoom_support) {
        mCfgMutex.lock();
        rk_aiq_uapi_af_endZoomChg(mAlgoCtx);
        mCfgMutex.unlock();
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

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

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

    if (sharedCom->snsDes.lens_des.zoom_support) {
        mCfgMutex.lock();
        rk_aiq_uapi_af_startZoomCalib(mAlgoCtx);
        isUpdateZoomPosDone = true;
        waitSignal();
        mCfgMutex.unlock();
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

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

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

    if (sharedCom->snsDes.lens_des.zoom_support) {
        mCfgMutex.lock();
        rk_aiq_uapi_af_resetZoom(mAlgoCtx);
        isUpdateZoomPosDone = true;
        waitSignal();
        mCfgMutex.unlock();
    }

    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::GetFocusRange(rk_aiq_af_focusrange* range) {
    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_getFocusRange(mAlgoCtx, range);

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn RkAiqAfHandleInt::GetCustomAfRes(rk_tool_customAf_res_t* att) {
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcResAf* af_com = &mProcResShared->result;
    RkAiqAlgoProcResAf* af_rk = (RkAiqAlgoProcResAf*)af_com;
    int i;

    memset(att, 0, sizeof(*att));
#if defined(ISP_HW_V30)
    rk_aiq_isp_af_meas_v3x_t* af_param = &af_rk->af_isp_param_v3x;

    att->af_en = af_param->af_en;
    att->rawaf_sel = af_param->rawaf_sel;
    att->gamma_en = af_param->gamma_en;
    att->gaus_en = af_param->gaus_en;
    att->v1_fir_sel = af_param->v1_fir_sel;
    att->hiir_en = af_param->hiir_en;
    att->viir_en = af_param->viir_en;
    att->v1_fv_outmode = af_param->v1_fv_outmode;
    att->v2_fv_outmode = af_param->v2_fv_outmode;
    att->h1_fv_outmode = af_param->h1_fv_outmode;
    att->h2_fv_outmode = af_param->h2_fv_outmode;
    att->ldg_en = af_param->ldg_en;
    att->accu_8bit_mode = af_param->accu_8bit_mode;
    att->ae_mode = af_param->ae_mode;
    att->y_mode = af_param->y_mode;

    att->window_num = af_param->window_num;
    att->wina_h_offs = af_param->wina_h_offs;
    att->wina_v_offs = af_param->wina_v_offs;
    att->wina_h_size = af_param->wina_h_size;
    att->wina_v_size = af_param->wina_v_size;
    att->winb_h_offs = af_param->winb_h_offs;
    att->winb_v_offs = af_param->winb_v_offs;
    att->winb_h_size = af_param->winb_h_size;
    att->winb_v_size = af_param->winb_v_size;

    for (i = 0; i < RKAIQ_RAWAF_GAMMA_NUM; i++)
        att->gamma_y[i] = af_param->gamma_y[i];

    att->thres = af_param->thres;
    att->shift_sum_a = af_param->shift_sum_a;
    att->shift_sum_b = af_param->shift_sum_b;
    att->shift_y_a = af_param->shift_y_a;
    att->shift_y_b = af_param->shift_y_b;

    for (i = 0; i < 9; i++)
        att->v1_iir_coe[i] = af_param->v1_iir_coe[i] << 2;
    for (i = 0; i < 3; i++) {
        att->v1_fir_coe[i] = af_param->v1_fir_coe[i];
        att->v2_iir_coe[i] = af_param->v2_iir_coe[i];
        att->v2_fir_coe[i] = af_param->v2_fir_coe[i];
    }

    for (i = 0; i < 6; i++) {
        att->h1_iir1_coe[i] = af_param->h1_iir1_coe[i];
        att->h2_iir1_coe[i] = af_param->h2_iir1_coe[i];
        att->h1_iir2_coe[i] = af_param->h1_iir2_coe[i];
        att->h2_iir2_coe[i] = af_param->h2_iir2_coe[i];
    }

    for (i = 0; i < 2; i++) {
        att->h_ldg_lumth[i] = af_param->h_ldg_lumth[i];
        att->h_ldg_gain[i] = af_param->h_ldg_gain[i];
        att->h_ldg_gslp[i] = af_param->h_ldg_gslp[i];
        att->v_ldg_lumth[i] = af_param->v_ldg_lumth[i];
        att->v_ldg_gain[i] = af_param->v_ldg_gain[i];
        att->v_ldg_gslp[i] = af_param->v_ldg_gslp[i];
    }

    att->v_fv_thresh = af_param->v_fv_thresh;
    att->h_fv_thresh = af_param->h_fv_thresh;
    att->v1_fv_shift = af_param->v1_fv_shift;
    att->v2_fv_shift = af_param->v2_fv_shift;
    att->h1_fv_shift = af_param->h1_fv_shift;
    att->h2_fv_shift = af_param->h2_fv_shift;
    att->highlit_thresh = af_param->highlit_thresh;
#endif

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

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

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

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

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

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

    // for otp
    af_config_int->otp_af = sharedCom->snsDes.otp_af;
    af_config_int->otp_pdaf = sharedCom->snsDes.otp_pdaf;

    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;

    RkAiqAlgoPreAf* af_pre_int        = (RkAiqAlgoPreAf*)mPreInParam;
    RkAiqAlgoPreResAf* af_pre_res_int = (RkAiqAlgoPreResAf*)mPreOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    ret = RkAiqHandle::preProcess();
    if (ret) {
        RKAIQCORE_CHECK_RET(ret, "af handle preProcess failed");
    }

    RkAiqAfStats* xAfStats = nullptr;
    if (shared->afStatsBuf) {
        xAfStats = (RkAiqAfStats*)shared->afStatsBuf->map(shared->afStatsBuf);
        if (!xAfStats) LOGE("af stats is null");
    } else {
        LOGW("the xcamvideobuffer of af stats is null");
    }

    if ((!xAfStats || !xAfStats->af_stats_valid) && !sharedCom->init) {
        LOGW("no af stats, ignore!");
        return XCAM_RETURN_BYPASS;
    }

    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");

    EXIT_ANALYZER_FUNCTION();
    return XCAM_RETURN_NO_ERROR;
}

bool RkAiqAfHandleInt::getValueFromFile(const char* path, int* pos) {
    const char* delim = " ";
    char buffer[16]   = {0};
    int fp;

    fp = open(path, O_RDONLY | O_SYNC);
    if (fp != -1) {
        if (read(fp, buffer, sizeof(buffer)) <= 0) {
            LOGE_AF("%s read %s failed!", __func__, path);
            goto OUT;
        } else {
            char* p = nullptr;

            p = strtok(buffer, delim);
            if (p != nullptr) {
                *pos = atoi(p);
            }
        }
        close(fp);
        return true;
    }

OUT:
    return false;
}

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

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

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

#define ZOOM_MOVE_DEBUG
#ifdef ZOOM_MOVE_DEBUG
    int zoom_index = 0;

    if (getValueFromFile("/data/.zoom_pos", &zoom_index) == true) {
        if (mLastZoomIndex != zoom_index) {
            setZoomIndex(zoom_index);
            endZoomChg();
            mLastZoomIndex = zoom_index;
        }
    }
#endif

    ret = RkAiqHandle::processing();
    if (ret) {
        RKAIQCORE_CHECK_RET(ret, "af handle processing failed");
    }

    RkAiqAfStats* xAfStats = nullptr;
    if (shared->afStatsBuf) {
        xAfStats = (RkAiqAfStats*)shared->afStatsBuf->map(shared->afStatsBuf);
        if (!xAfStats) LOGE("af stats is null");
    } else {
        LOGW("the xcamvideobuffer of af stats is null");
    }

    if ((!xAfStats || !xAfStats->af_stats_valid) && !sharedCom->init) {
        LOGW("no af stats, ignore!");
        mProcResShared.release();
        return XCAM_RETURN_BYPASS;
    }

    af_proc_int->xcam_af_stats  = shared->afStatsBuf;
    af_proc_int->xcam_aec_stats = shared->aecStatsBuf;
    af_proc_int->xcam_pdaf_stats = shared->pdafStatsBuf;

    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");

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

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

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

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoPostAf* af_post_int        = (RkAiqAlgoPostAf*)mPostInParam;
    RkAiqAlgoPostResAf* af_post_res_int = (RkAiqAlgoPostResAf*)mPostOutParam;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    ret = RkAiqHandle::postProcess();
    if (ret) {
        RKAIQCORE_CHECK_RET(ret, "af handle postProcess failed");
        return ret;
    }

    RkAiqAfStats* xAfStats = nullptr;
    if (shared->afStatsBuf) {
        xAfStats = (RkAiqAfStats*)shared->afStatsBuf->map(shared->afStatsBuf);
        if (!xAfStats) LOGE("af stats is null");
    } else {
        LOGW("the xcamvideobuffer of af stats is null");
    }

    if ((!xAfStats || !xAfStats->af_stats_valid) && !sharedCom->init) {
        LOGW("no af stats, ignore!");
        return XCAM_RETURN_BYPASS;
    }

    RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
    ret                       = des->post_process(mPostInParam, mPostOutParam);
    RKAIQCORE_CHECK_RET(ret, "af algo post_process failed");

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

    if (isUpdateZoomPosDone) {
        isUpdateZoomPosDone = false;
        sendSignal();
    }

    EXIT_ANALYZER_FUNCTION();
    return ret;
}

XCamReturn RkAiqAfHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    RkAiqCore::RkAiqAlgosGroupShared_t* shared =
        (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    if (!mProcResShared.ptr())
        return XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcResAf* af_com                  = &mProcResShared->result;

#if defined(ISP_HW_V30)
    rk_aiq_isp_af_params_v3x_t* af_param = params->mAfV3xParams->data().ptr();
#else
    rk_aiq_isp_af_params_v20_t* af_param = params->mAfParams->data().ptr();
#endif

    SmartPtr<rk_aiq_focus_params_wrapper_t> focus_param = params->mFocusParams->data();
    rk_aiq_focus_params_t* p_focus_param                = &focus_param->result;

#if 0
    isp_param->af_cfg_update = false;
#else
    // af_param->af_cfg_update = false;
#endif
    memset(p_focus_param, 0, sizeof(rk_aiq_focus_params_t));
    if (!af_com) {
        LOGD_ANALYZER("no af result");
        return XCAM_RETURN_NO_ERROR;
    }

    if (!this->getAlgoId()) {
        RkAiqAlgoProcResAf* af_rk = (RkAiqAlgoProcResAf*)af_com;

#if 0
        isp_param->af_meas = af_rk->af_isp_param;
        isp_param->af_cfg_update = af_rk->af_cfg_update;
#else
        if (sharedCom->init) {
            af_param->frame_id    = 0;
            focus_param->frame_id = 0;
        } else {
            af_param->frame_id    = shared->frameId;
            focus_param->frame_id = shared->frameId;
        }
#if defined(ISP_HW_V30)
        af_param->result = af_rk->af_isp_param_v3x;
#else
        af_param->result = af_rk->af_isp_param;
#endif
        // isp_param->af_cfg_update = af_rk->af_cfg_update;
#endif
        p_focus_param->zoomfocus_modifypos =
            af_rk->af_focus_param.zoomfocus_modifypos;
        p_focus_param->focus_correction  = af_rk->af_focus_param.focus_correction;
        p_focus_param->zoom_correction   = af_rk->af_focus_param.zoom_correction;
        p_focus_param->lens_pos_valid    = af_rk->af_focus_param.lens_pos_valid;
        p_focus_param->zoom_pos_valid    = af_rk->af_focus_param.zoom_pos_valid;
        p_focus_param->send_zoom_reback  = af_rk->af_focus_param.send_zoom_reback;
        p_focus_param->send_focus_reback = af_rk->af_focus_param.send_focus_reback;
        p_focus_param->end_zoom_chg      = af_rk->af_focus_param.end_zoom_chg;
        p_focus_param->focus_noreback    = af_rk->af_focus_param.focus_noreback;
        p_focus_param->use_manual        = af_rk->af_focus_param.use_manual;
        p_focus_param->auto_focpos       = af_rk->af_focus_param.auto_focpos;
        p_focus_param->auto_zoompos      = af_rk->af_focus_param.auto_zoompos;
        p_focus_param->manual_focpos     = af_rk->af_focus_param.manual_focpos;
        p_focus_param->manual_zoompos    = af_rk->af_focus_param.manual_zoompos;
        p_focus_param->next_pos_num      = af_rk->af_focus_param.next_pos_num;
        for (int i = 0; i < af_rk->af_focus_param.next_pos_num; i++) {
            p_focus_param->next_lens_pos[i] =
                af_rk->af_focus_param.next_lens_pos[i];
            p_focus_param->next_zoom_pos[i] =
                af_rk->af_focus_param.next_zoom_pos[i];
        }

        p_focus_param->vcm_start_ma     = af_rk->af_focus_param.vcm_start_ma;
        p_focus_param->vcm_end_ma       = af_rk->af_focus_param.vcm_end_ma;
        p_focus_param->vcm_config_valid = af_rk->af_focus_param.vcm_config_valid;

#if defined(ISP_HW_V30) || defined(ISP_HW_V21)
        SmartPtr<RkAiqHandle>* ae_handle = mAiqCore->getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AE);
        int algo_id                      = (*ae_handle)->getAlgoId();

        if (ae_handle) {
            if (algo_id == 0) {
                RkAiqAeHandleInt* ae_algo = dynamic_cast<RkAiqAeHandleInt*>(ae_handle->ptr());

                if (af_rk->lockae_en)
                    ae_algo->setLockAeForAf(af_rk->lockae);
                else
                    ae_algo->setLockAeForAf(false);
            }
        }
#endif
    }

#if defined(ISP_HW_V30)
    cur_params->mAfV3xParams = params->mAfV3xParams;
#else
    cur_params->mAfParams    = params->mAfParams;
#endif
    cur_params->mFocusParams = params->mFocusParams;

    EXIT_ANALYZER_FUNCTION();

    return ret;
}

};  // namespace RkCam