/*
 * rk_aiq_algo_afec_itf.c
 *
 *  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 "rk_aiq_algo_types_int.h"
#include "afec/rk_aiq_algo_afec_itf.h"
#include "afec/rk_aiq_types_afec_algo_prvt.h"
#include "xcam_log.h"

#define EPSINON 0.0000001

RKAIQ_BEGIN_DECLARE

static XCamReturn release_fec_buf(FECContext_t* fecCtx);
static XCamReturn alloc_fec_buf(FECContext_t* fecCtx)
{
    // release-first
    release_fec_buf(fecCtx);
    rk_aiq_share_mem_config_t share_mem_config;
    share_mem_config.alloc_param.width =  fecCtx->dst_width;
    share_mem_config.alloc_param.height = fecCtx->dst_height;
    share_mem_config.alloc_param.reserved[0] = fecCtx->mesh_density;
    share_mem_config.mem_type = MEM_TYPE_FEC;
    fecCtx->share_mem_ops->alloc_mem(fecCtx->share_mem_ops,
                                     &share_mem_config,
                                     &fecCtx->share_mem_ctx);
    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn release_fec_buf(FECContext_t* fecCtx)
{
    if (fecCtx->share_mem_ctx)
        fecCtx->share_mem_ops->release_mem(fecCtx->share_mem_ctx);

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn get_fec_buf(FECContext_t* fecCtx)
{
    fecCtx->fec_mem_info = (rk_aiq_fec_share_mem_info_t *)
            fecCtx->share_mem_ops->get_free_item(fecCtx->share_mem_ctx);
    if (fecCtx->fec_mem_info == NULL) {
        LOGE_AFEC( "%s(%d): no free fec buf", __FUNCTION__, __LINE__);
        return XCAM_RETURN_ERROR_MEM;
    } else {
        LOGD_AFEC("get buf fd=%d\n",fecCtx->fec_mem_info->fd);
        fecCtx->meshxi = fecCtx->fec_mem_info->meshxi;
        fecCtx->meshxf = fecCtx->fec_mem_info->meshxf;
        fecCtx->meshyi = fecCtx->fec_mem_info->meshyi;
        fecCtx->meshyf = fecCtx->fec_mem_info->meshyf;
    }
    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
gen_mesh_table(
    float k1, float k2, float p1, float p2, float k3,
    int src_width, int src_height,
    int mesh_h_size, int mesh_v_size,
    int* meshxi, int* meshxf, int* meshyi, int* meshyf) {
    //TODO::implement mesh table generation function
    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
create_context(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
{
    RkAiqAlgoContext *ctx = new RkAiqAlgoContext();
    if (ctx == NULL) {
        LOGE_AFEC( "%s: create afec context fail!\n", __FUNCTION__);
        return XCAM_RETURN_ERROR_MEM;
    }
    ctx->hFEC = new FECContext_t();
    if (ctx->hFEC == NULL) {
        LOGE_AFEC( "%s: create afec handle fail!\n", __FUNCTION__);
        return XCAM_RETURN_ERROR_MEM;
    }
    memset((void *)(ctx->hFEC), 0, sizeof(FECContext_t));
    *context = ctx;

    const AlgoCtxInstanceCfgInt* cfg_int = (const AlgoCtxInstanceCfgInt*)cfg;
    FECHandle_t fecCtx = ctx->hFEC;

    CalibDbV2_FEC_t* calib_fec_db =
            (CalibDbV2_FEC_t*)(CALIBDBV2_GET_MODULE_PTR(cfg_int->calibv2, afec));
    CalibDbV2_Fec_Param_t* calib_fec = &calib_fec_db->param;
    CalibDbV2_Eis_t* calib_eis =
                (CalibDbV2_Eis_t*)(CALIBDBV2_GET_MODULE_PTR(cfg_int->calibv2, eis_calib));

    memset(&fecCtx->user_config, 0, sizeof(fecCtx->user_config));
    fecCtx->fec_en = fecCtx->user_config.en = calib_eis->enable ? 0 : calib_fec->fec_en;
    if (!fecCtx->fec_en) {
        if (calib_eis->enable) {
            LOGE_AFEC("FEC diabled because of EIS");
        }
        return XCAM_RETURN_NO_ERROR;
    }

#if GENMESH_ONLINE
    ctx->hFEC->isAttribUpdated = false;
    ctx->hFEC->afecReadMeshThread = new RKAiqAfecThread(ctx->hFEC);
#endif

    memcpy(fecCtx->meshfile, calib_fec->meshfile, sizeof(fecCtx->meshfile));
#if GENMESH_ONLINE
    fecCtx->camCoeff.cx = calib_fec->light_center[0];
    fecCtx->camCoeff.cy = calib_fec->light_center[1];
    fecCtx->camCoeff.a0 = calib_fec->coefficient[0];
    fecCtx->camCoeff.a2 = calib_fec->coefficient[1];
    fecCtx->camCoeff.a3 = calib_fec->coefficient[2];
    fecCtx->camCoeff.a4 = calib_fec->coefficient[3];
    LOGI_AFEC("(%s) len light center(%.16f, %.16f)\n",
            __FUNCTION__,
            fecCtx->camCoeff.cx, fecCtx->camCoeff.cy);
    LOGI_AFEC("(%s) len coefficient(%.16f, %.16f, %.16f, %.16f)\n",
            __FUNCTION__,
            fecCtx->camCoeff.a0, fecCtx->camCoeff.a2,
            fecCtx->camCoeff.a3, fecCtx->camCoeff.a4);
#endif
    fecCtx->correct_level = calib_fec->correct_level;
    fecCtx->correct_level = fecCtx->user_config.correct_level = calib_fec->correct_level;
    fecCtx->correct_direction = fecCtx->user_config.direction = FEC_CORRECT_DIRECTION_XY;
    fecCtx->fecParams.correctX = 1;
    fecCtx->fecParams.correctY = 1;
    fecCtx->fecParams.saveMesh4bin = 0;

    ctx->hFEC->eState = FEC_STATE_INVALID;

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
destroy_context(RkAiqAlgoContext *context)
{
    FECHandle_t hFEC = (FECHandle_t)context->hFEC;
    FECContext_t* fecCtx = (FECContext_t*)hFEC;
#if GENMESH_ONLINE
    if (fecCtx->fec_en) {
        fecCtx->afecReadMeshThread->triger_stop();
        fecCtx->afecReadMeshThread->stop();
        //    if (fecCtx->meshxi != NULL || fecCtx->meshyi != NULL ||
        //        fecCtx->meshxf != NULL || fecCtx->meshyf != NULL)
        //        freeFecMesh(fecCtx->meshxi, fecCtx->meshxf,
        //                fecCtx->meshyi, fecCtx->meshyf);
        genFecMeshDeInit(fecCtx->fecParams);
    }
#else
//    if (fecCtx->meshxi != NULL) {
//        free(fecCtx->meshxi);
//        fecCtx->meshxi = NULL;
//    }
 
//    if (fecCtx->meshyi != NULL) {
//        free(fecCtx->meshyi);
//        fecCtx->meshyi = NULL;
//    }

//    if (fecCtx->meshxf != NULL) {
//        free(fecCtx->meshxf);
//        fecCtx->meshxf = NULL;
//    }
//
//    if (fecCtx->meshyf != NULL) {
//        free(fecCtx->meshyf);
//        fecCtx->meshyf = NULL;
//    }
#endif
    release_fec_buf(fecCtx);
    delete context->hFEC;
    context->hFEC = NULL;
    delete context;
    context = NULL;
    return XCAM_RETURN_NO_ERROR;
}

#define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
#define ALIGN(x,a)      __ALIGN_MASK(x, a-1)

uint32_t cal_fec_mesh(uint32_t width, uint32_t height, uint32_t mode, uint32_t &meshw, uint32_t &meshh)
{
    uint32_t mesh_size, mesh_left_height;
    uint32_t w = ALIGN(width, 32);
    uint32_t h = ALIGN(height, 32);
    uint32_t spb_num = (h + 127) >> 7;
    uint32_t left_height = h & 127;
    uint32_t mesh_width = mode ? (w / 32 + 1) : (w / 16 + 1);
    uint32_t mesh_height = mode ? 9 : 17;

    if (!left_height)
        left_height = 128;
    mesh_left_height = mode ? (left_height / 16 + 1) :
                       (left_height / 8 + 1);
    mesh_size = (spb_num - 1) * mesh_width * mesh_height +
                mesh_width * mesh_left_height;

    meshw = mesh_width;
    meshh = (spb_num - 1) * mesh_height + (spb_num - 1);
    return mesh_size;
}

static XCamReturn
read_mesh_table(FECContext_t* fecCtx, unsigned int correct_level)
{
    bool ret;
#if OPENCV_SUPPORT
    gen_default_mesh_table(fecCtx->src_width, fecCtx->src_height, fecCtx->mesh_density,
                           fecCtx->meshxi, fecCtx->meshyi, fecCtx->meshxf, fecCtx->meshyf);
#elif GENMESH_ONLINE
    ret = genFECMeshNLevel(fecCtx->fecParams, fecCtx->camCoeff, correct_level, fecCtx->meshxi,
                           fecCtx->meshxf, fecCtx->meshyi, fecCtx->meshyf);
    if (!ret) {
        LOGE_AFEC("afec gen mesh false!");
        return XCAM_RETURN_ERROR_FAILED;
    }
#else
    FILE* ofp;
    char filename[512];
    sprintf(filename, "%s/%s/meshxi_level%d.bin",
            fecCtx->resource_path,
            fecCtx->meshfile,
            correct_level);
    ofp = fopen(filename, "rb");
    if (ofp != NULL) {
        unsigned int num = fread(fecCtx->meshxi, 1, fecCtx->fec_mesh_size * sizeof(unsigned short), ofp);
        fclose(ofp);

        if (num != fecCtx->fec_mesh_size * sizeof(unsigned short)) {
            fecCtx->fec_en = 0;
            LOGE_AFEC("mismatched mesh XI file");
        }
    } else {
        LOGE_AFEC("mesh XI file %s not exist", filename);
        fecCtx->fec_en = 0;
    }

    sprintf(filename, "%s/%s/meshxf_level%d.bin",
            fecCtx->resource_path,
            fecCtx->meshfile,
            correct_level);
    ofp = fopen(filename, "rb");
    if (ofp != NULL) {
        unsigned int num = fread(fecCtx->meshxf, 1, fecCtx->fec_mesh_size * sizeof(unsigned char), ofp);
        fclose(ofp);
        if (num != fecCtx->fec_mesh_size * sizeof(unsigned char)) {
            fecCtx->fec_en = 0;
            LOGE_AFEC("mismatched mesh XF file");
        }
    } else {
        LOGE_AFEC("mesh XF file %s not exist", filename);
        fecCtx->fec_en = 0;
    }

    sprintf(filename, "%s/%s/meshyi_level%d.bin",
            fecCtx->resource_path,
            fecCtx->meshfile,
            correct_level);
    ofp = fopen(filename, "rb");
    if (ofp != NULL) {
        unsigned int num = fread(fecCtx->meshyi, 1, fecCtx->fec_mesh_size * sizeof(unsigned short), ofp);
        fclose(ofp);
        if (num != fecCtx->fec_mesh_size * sizeof(unsigned short)) {
            fecCtx->fec_en = 0;
            LOGE_AFEC("mismatched mesh YI file");
        }
    } else {
        LOGE_AFEC("mesh YI file %s not exist", filename);
        fecCtx->fec_en = 0;
    }

    sprintf(filename, "%s/%s/meshyf_level%d.bin",
            fecCtx->resource_path,
            fecCtx->meshfile,
            correct_level);
    ofp = fopen(filename, "rb");
    if (ofp != NULL) {
        unsigned int num = fread(fecCtx->meshyf, 1, fecCtx->fec_mesh_size * sizeof(unsigned char), ofp);
        fclose(ofp);
        if (num != fecCtx->fec_mesh_size * sizeof(unsigned char)) {
            fecCtx->fec_en = 0;
            LOGE_AFEC("mismatched mesh YF file");
        }
    } else {
        LOGE_AFEC("mesh YF file %s not exist", filename);
        fecCtx->fec_en = 0;
    }
#endif

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
prepare(RkAiqAlgoCom* params)
{
    FECHandle_t hFEC = (FECHandle_t)params->ctx->hFEC;
    FECContext_t* fecCtx = (FECContext_t*)hFEC;
    RkAiqAlgoConfigAfecInt* rkaiqAfecConfig = (RkAiqAlgoConfigAfecInt*)params;

    if (!fecCtx->fec_en)
        return XCAM_RETURN_NO_ERROR;

#if 0 //moved to create_ctx
    fecCtx->fec_en = rkaiqAfecConfig->afec_calib_cfg.fec_en;
    memcpy(fecCtx->meshfile, rkaiqAfecConfig->afec_calib_cfg.meshfile, sizeof(fecCtx->meshfile));
    fecCtx->camCoeff.cx = rkaiqAfecConfig->afec_calib_cfg.light_center[0];
    fecCtx->camCoeff.cy = rkaiqAfecConfig->afec_calib_cfg.light_center[1];
    fecCtx->camCoeff.a0 = rkaiqAfecConfig->afec_calib_cfg.coefficient[0];
    fecCtx->camCoeff.a2 = rkaiqAfecConfig->afec_calib_cfg.coefficient[1];
    fecCtx->camCoeff.a3 = rkaiqAfecConfig->afec_calib_cfg.coefficient[2];
    fecCtx->camCoeff.a4 = rkaiqAfecConfig->afec_calib_cfg.coefficient[3];
    LOGI_AFEC("(%s) len light center(%.16f, %.16f)\n",
            __FUNCTION__,
            fecCtx->camCoeff.cx, fecCtx->camCoeff.cy);
    LOGI_AFEC("(%s) len coefficient(%.16f, %.16f, %.16f, %.16f)\n",
            __FUNCTION__,
            fecCtx->camCoeff.a0, fecCtx->camCoeff.a2,
            fecCtx->camCoeff.a3, fecCtx->camCoeff.a4);
#endif
    fecCtx->share_mem_ops = rkaiqAfecConfig->mem_ops_ptr;
    fecCtx->src_width = params->u.prepare.sns_op_width;
    fecCtx->src_height = params->u.prepare.sns_op_height;
    fecCtx->resource_path = rkaiqAfecConfig->resource_path;
    fecCtx->dst_width = params->u.prepare.sns_op_width;
    fecCtx->dst_height = params->u.prepare.sns_op_height;

    if (fecCtx->src_width <= 1920) {
        fecCtx->mesh_density = 0;
    } else {
        fecCtx->mesh_density = 1;
    }

#if GENMESH_ONLINE
    // process the new attrib set before prepare
    fecCtx->afecReadMeshThread->triger_stop();
    fecCtx->afecReadMeshThread->stop();
    if (!fecCtx->afecReadMeshThread->is_empty()) {
        fecCtx->afecReadMeshThread->clear_attr();
        fecCtx->isAttribUpdated = true;
    }
#endif

    double correct_level = fecCtx->correct_level;
    if (fecCtx->isAttribUpdated) {
        fecCtx->fec_en = fecCtx->user_config.en;
        if (fecCtx->user_config.bypass)
            correct_level = 0;
        correct_level = fecCtx->user_config.correct_level;
        switch (fecCtx->user_config.direction) {
        case FEC_CORRECT_DIRECTION_X:
            fecCtx->fecParams.correctY = 0;
            fecCtx->correct_direction = fecCtx->user_config.direction;
            break;
        case FEC_CORRECT_DIRECTION_Y:
            fecCtx->fecParams.correctX = 0;
            fecCtx->correct_direction = fecCtx->user_config.direction;
            break;
        default:
            break;
        }

        fecCtx->mode = fecCtx->user_config.mode;
        switch (fecCtx->mode) {
        case FEC_COMPRES_IMAGE_KEEP_FOV:
            fecCtx->fecParams.saveMaxFovX = 1;
            break;
        case FEC_KEEP_ASPECT_RATIO_REDUCE_FOV:
            fecCtx->fecParams.saveMaxFovX = 0;
            break;
        case FEC_ALTER_ASPECT_RATIO_KEEP_FOV:
            break;
        default:
            break;
        }

        if (fecCtx->fecParams.saveMesh4bin)
            sprintf(fecCtx->fecParams.mesh4binPath, "/tmp/");

        fecCtx->isAttribUpdated = false;
    } else {
        fecCtx->user_config.en = fecCtx->fec_en;
    }
    fecCtx->user_config.correct_level = correct_level;

#if GENMESH_ONLINE
    // deinit firtly
    if (fecCtx->fecParams.pMeshXY)
        genFecMeshDeInit(fecCtx->fecParams);

    //if (fecCtx->meshxi != NULL || fecCtx->meshyi != NULL ||
    //    fecCtx->meshxf != NULL || fecCtx->meshyf != NULL)
    //    freeFecMesh(fecCtx->meshxi, fecCtx->meshxf,
    //            fecCtx->meshyi, fecCtx->meshyf);

    fecCtx->fecParams.isFecOld = 1;
    genFecMeshInit(fecCtx->src_width, fecCtx->src_height, fecCtx->dst_width,
            fecCtx->dst_height, fecCtx->fecParams, fecCtx->camCoeff);
    //mallocFecMesh(fecCtx->fecParams.meshSize4bin, &fecCtx->meshxi,
    //        &fecCtx->meshxf, &fecCtx->meshyi, &fecCtx->meshyf);
    fecCtx->fec_mesh_h_size = fecCtx->fecParams.meshSizeW;
    fecCtx->fec_mesh_v_size = fecCtx->fecParams.meshSizeH;
    alloc_fec_buf(fecCtx);
    get_fec_buf(fecCtx);
    fecCtx->fec_mesh_size = fecCtx->fecParams.meshSize4bin;
    LOGI_AFEC("en: %d, mode(%d), bypass(%d), correct_level(%d), direction(%d), dimen(%d-%d), mesh dimen(%d-%d), size(%d)",
              fecCtx->fec_en,
              fecCtx->mode,
              fecCtx->user_config.bypass,
              fecCtx->user_config.correct_level,
              fecCtx->correct_direction,
              fecCtx->src_width, fecCtx->src_height,
              fecCtx->fec_mesh_h_size, fecCtx->fec_mesh_v_size,
              fecCtx->fec_mesh_size);

    fecCtx->afecReadMeshThread->triger_start();
    fecCtx->afecReadMeshThread->start();
    if (!fecCtx->fec_en)
        return XCAM_RETURN_NO_ERROR;
#else
    fecCtx->fec_mesh_size =
        cal_fec_mesh(fecCtx->src_width, fecCtx->src_height, fecCtx->mesh_density,
                     fecCtx->fec_mesh_h_size, fecCtx->fec_mesh_v_size);

    LOGI_AFEC("(%s) en: %d, user_en: %d, correct_level: %d, dimen: %d-%d, mesh dimen: %d-%d, size: %d",
              fecCtx->meshfile, fecCtx->fec_en,
              fecCtx->user_config.en, fecCtx->user_config.correct_level,
              fecCtx->src_width, fecCtx->src_height,
              fecCtx->fec_mesh_h_size, fecCtx->fec_mesh_v_size,
              fecCtx->fec_mesh_size);
    if (!fecCtx->fec_en)
        return XCAM_RETURN_NO_ERROR;

    // need realloc ?
    if (fecCtx->meshxi) {
        free(fecCtx->meshxi);
        fecCtx->meshxi = NULL;
    }
    if (fecCtx->meshxf) {
        free(fecCtx->meshxf);
        fecCtx->meshxf = NULL;
    }
    if (fecCtx->meshyi) {
        free(fecCtx->meshyi);
        fecCtx->meshyi = NULL;
    }
    if (fecCtx->meshyf) {
        free(fecCtx->meshyf);
        fecCtx->meshyf = NULL;
    }
    fecCtx->meshxi = (unsigned short*)malloc(fecCtx->fec_mesh_size * sizeof(unsigned short));
    fecCtx->meshxf = (unsigned char*)malloc(fecCtx->fec_mesh_size * sizeof(unsigned char));
    fecCtx->meshyi = (unsigned short*)malloc(fecCtx->fec_mesh_size * sizeof(unsigned short));
    fecCtx->meshyf = (unsigned char*)malloc(fecCtx->fec_mesh_size * sizeof(unsigned char));

#endif
    read_mesh_table(fecCtx, fecCtx->user_config.correct_level);
    fecCtx->eState = FEC_STATE_INITIALIZED;

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    FECHandle_t hFEC = (FECHandle_t)inparams->ctx->hFEC;
    FECContext_t* fecCtx = (FECContext_t*)hFEC;
    RkAiqAlgoProcAfecInt* fecProcParams = (RkAiqAlgoProcAfecInt*)inparams;
    RkAiqAlgoProcResAfecInt* fecPreOut = (RkAiqAlgoProcResAfecInt*)outparams;

    if (!fecCtx->fec_en)
        return XCAM_RETURN_NO_ERROR;

    fecPreOut->afec_result.sw_fec_en = fecCtx->fec_en;
    fecPreOut->afec_result.crop_en = 0;
    fecPreOut->afec_result.crop_width = 0;
    fecPreOut->afec_result.crop_height = 0;
    fecPreOut->afec_result.mesh_density = fecCtx->mesh_density;
    fecPreOut->afec_result.mesh_size = fecCtx->fec_mesh_size;
    // TODO: should check the fec mode,
    // if mode == RK_AIQ_ISPP_STATIC_FEC_WORKING_MODE_STABLIZATION
    // params may be changed
    fecCtx->eState = FEC_STATE_RUNNING;

    if (inparams->u.proc.init) {
        fecPreOut->afec_result.update = 1;
    } else {

        if (fecCtx->isAttribUpdated) {
            fecCtx->isAttribUpdated = false;
            fecPreOut->afec_result.update = 1;
        } else {
            fecPreOut->afec_result.update = 0;
        }

        LOGV_AFEC("en(%d), bypass(%d), level(%d), direction(%d), result update(%d)\n",
                fecCtx->fec_en,
                fecCtx->user_config.bypass,
                fecCtx->correct_level,
                fecCtx->correct_direction,
                fecPreOut->afec_result.update);
    }

    if (fecPreOut->afec_result.update) {
        //memcpy(fecPreOut->afec_result.meshxi, fecCtx->meshxi,
        //       fecCtx->fec_mesh_size * sizeof(unsigned short));
        //memcpy(fecPreOut->afec_result.meshxf, fecCtx->meshxf,
        //       fecCtx->fec_mesh_size * sizeof(unsigned char));
        //memcpy(fecPreOut->afec_result.meshyi, fecCtx->meshyi,
        //       fecCtx->fec_mesh_size * sizeof(unsigned short));
        //memcpy(fecPreOut->afec_result.meshyf, fecCtx->meshyf,
        //       fecCtx->fec_mesh_size * sizeof(unsigned char));

        if (fecCtx->fec_mem_info == NULL) {
            LOGE_AFEC("%s: no available fec buf!", __FUNCTION__);
            fecPreOut->afec_result.update = 0;
            return XCAM_RETURN_NO_ERROR;
        }
        fecPreOut->afec_result.mesh_buf_fd = fecCtx->fec_mem_info->fd;
        fecCtx->fec_mem_info->state[0] = 1; //mark that this buf is using.
    }

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    return XCAM_RETURN_NO_ERROR;
}

RkAiqAlgoDescription g_RkIspAlgoDescAfec = {
    .common = {
        .version = RKISP_ALGO_AFEC_VERSION,
        .vendor  = RKISP_ALGO_AFEC_VENDOR,
        .description = RKISP_ALGO_AFEC_DESCRIPTION,
        .type    = RK_AIQ_ALGO_TYPE_AFEC,
        .id      = 0,
        .create_context  = create_context,
        .destroy_context = destroy_context,
    },
    .prepare = prepare,
    .pre_process = pre_process,
    .processing = processing,
    .post_process = post_process,
};

RKAIQ_END_DECLARE

bool RKAiqAfecThread::loop()
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ENTER_ANALYZER_FUNCTION();

    const static int32_t timeout = -1;
    SmartPtr<rk_aiq_fec_cfg_t> attrib = mAttrQueue.pop (timeout);

    if (!attrib.ptr()) {
        LOGW_ANALYZER("RKAiqAfecThread got empty attrib, stop thread");
        return false;
    }

    if (hFEC->eState != FEC_STATE_RUNNING) {
        hFEC->isAttribUpdated = true;
        return true;
    }
    get_fec_buf(hFEC);
    if (hFEC->user_config.bypass) {
        ret = read_mesh_table(hFEC, 0);
    } else {
        ret = read_mesh_table(hFEC, attrib->correct_level);
        hFEC->correct_level = attrib->correct_level;
    }

    if (ret == XCAM_RETURN_NO_ERROR) {
        hFEC->isAttribUpdated = true;
        return true;
    }

    LOGE_ANALYZER("RKAiqAfecThread failed to read mesh table!");

    EXIT_ANALYZER_FUNCTION();

    return false;
}