/*
 * RkAiqHandleInt.h
 *
 *  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.
 *
 */

#ifndef _RK_AIQ_HANDLE_INT_H_
#define _RK_AIQ_HANDLE_INT_H_

#include "RkAiqHandle.h"
#include "rk_aiq_algo_types_int.h"
#include "ae/rk_aiq_uapi_ae_int.h"
#include "awb/rk_aiq_uapi_awb_int.h"
#include "awb/rk_aiq_uapiv2_awb_int.h"
#include "adebayer/rk_aiq_uapi_adebayer_int.h"
#include "amerge/rk_aiq_uapi_amerge_int.h"
#include "atmo/rk_aiq_uapi_atmo_int.h"
#include "adrc/rk_aiq_uapi_adrc_int.h"
#include "alsc/rk_aiq_uapi_alsc_int.h"
#include "accm/rk_aiq_uapi_accm_int.h"
#include "a3dlut/rk_aiq_uapi_a3dlut_int.h"
#include "xcam_mutex.h"
#include "adehaze/rk_aiq_uapi_adehaze_int.h"
#include "agamma/rk_aiq_uapi_agamma_int.h"
#include "adegamma/rk_aiq_uapi_adegamma_int.h"
#include "ablc/rk_aiq_uapi_ablc_int.h"
#include "adpcc/rk_aiq_uapi_adpcc_int.h"
#include "anr/rk_aiq_uapi_anr_int.h"
#include "asharp/rk_aiq_uapi_asharp_int.h"
#include "agic/rk_aiq_uapi_agic_int.h"
#include "afec/rk_aiq_uapi_afec_int.h"
#include "af/rk_aiq_uapi_af_int.h"
#include "asd/rk_aiq_uapi_asd_int.h"
#include "aldch/rk_aiq_uapi_aldch_int.h"
#include "acp/rk_aiq_uapi_acp_int.h"
#include "aie/rk_aiq_uapi_aie_int.h"
#include "aeis/rk_aiq_uapi_aeis_int.h"
#include "arawnr/rk_aiq_uapi_abayernr_int_v1.h"
#include "aynr/rk_aiq_uapi_aynr_int_v1.h"
#include "auvnr/rk_aiq_uapi_auvnr_int_v1.h"
#include "amfnr/rk_aiq_uapi_amfnr_int_v1.h"
#include "again/rk_aiq_uapi_again_int.h"

#include "RkAiqSharedDataManager.h"
#include "rk_aiq_api_private.h"

namespace RkCam {

class RkAiqCore;

class RkAiqHandleIntCom : virtual public RkAiqHandle
{
public:
    explicit RkAiqHandleIntCom(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , updateAtt(false)
        , mUpdateCond(false) {};
    virtual ~RkAiqHandleIntCom() {};
protected:
    XCamReturn configInparamsCom(RkAiqAlgoCom* com, int type);
    void waitSignal();
    void sendSignal();
    XCam::Mutex mCfgMutex;
    bool updateAtt;
    XCam::Cond mUpdateCond;
};

#define RKAIQHANDLEINT(algo) \
    class RkAiq##algo##HandleInt: \
            virtual public RkAiq##algo##Handle, \
            virtual public RkAiqHandleIntCom { \
    public: \
        explicit RkAiq##algo##HandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore) \
                    : RkAiqHandle(des, aiqCore) \
                    , RkAiq##algo##Handle(des, aiqCore) \
                    , RkAiqHandleIntCom(des, aiqCore) {}; \
        virtual ~RkAiq##algo##HandleInt() { RkAiq##algo##Handle::deInit(); }; \
        virtual XCamReturn prepare(); \
        virtual XCamReturn preProcess(); \
        virtual XCamReturn processing(); \
        virtual XCamReturn postProcess(); \
    protected: \
        virtual void init(); \
        virtual void deInit() { RkAiq##algo##Handle::deInit(); }; \
    }

// define
//RKAIQHANDLEINT(Ae);
//RKAIQHANDLEINT(Awb);
//RKAIQHANDLEINT(Af);
//RKAIQHANDLEINT(Ahdr);
//RKAIQHANDLEINT(Anr);
//RKAIQHANDLEINT(Alsc);
//RKAIQHANDLEINT(Asharp);
//RKAIQHANDLEINT(Adhaz);
//RKAIQHANDLEINT(Asd);
//RKAIQHANDLEINT(Acp);
//RKAIQHANDLEINT(A3dlut);
//RKAIQHANDLEINT(Ablc);
//RKAIQHANDLEINT(Accm);
RKAIQHANDLEINT(Acgc);
//RKAIQHANDLEINT(Adebayer);
//RKAIQHANDLEINT(Adpcc);
// RKAIQHANDLEINT(Afec);
//RKAIQHANDLEINT(Agamma);
//RKAIQHANDLEINT(Agic);
//RKAIQHANDLEINT(Aie);
// RKAIQHANDLEINT(Aldch);
RKAIQHANDLEINT(Ar2y);
RKAIQHANDLEINT(Awdr);
RKAIQHANDLEINT(Aorb);
//RKAIQHANDLEINT(Aeis);
// ae
class RkAiqAeHandleInt:
    virtual public RkAiqAeHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAeHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAeHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore)
        , mPreResShared(nullptr)
        , mProcResShared(nullptr) {};
    virtual ~RkAiqAeHandleInt() {
        RkAiqAeHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();

    // TODO: calibv1
    XCamReturn setExpSwAttr(Uapi_ExpSwAttr_t ExpSwAttr);
    XCamReturn getExpSwAttr(Uapi_ExpSwAttr_t* pExpSwAttr);
    XCamReturn setLinExpAttr(Uapi_LinExpAttr_t LinExpAttr);
    XCamReturn getLinExpAttr(Uapi_LinExpAttr_t* pLinExpAttr);
    XCamReturn setHdrExpAttr(Uapi_HdrExpAttr_t HdrExpAttr);
    XCamReturn getHdrExpAttr (Uapi_HdrExpAttr_t* pHdrExpAttr);

    // TODO: calibv2
    XCamReturn setExpSwAttr(Uapi_ExpSwAttrV2_t ExpSwAttr);
    XCamReturn getExpSwAttr(Uapi_ExpSwAttrV2_t* pExpSwAttr);
    XCamReturn setLinExpAttr(Uapi_LinExpAttrV2_t LinExpAttr);
    XCamReturn getLinExpAttr(Uapi_LinExpAttrV2_t* pLinExpAttr);
    XCamReturn setHdrExpAttr(Uapi_HdrExpAttrV2_t HdrExpAttr);
    XCamReturn getHdrExpAttr (Uapi_HdrExpAttrV2_t* pHdrExpAttr);

    XCamReturn setLinAeRouteAttr(Uapi_LinAeRouteAttr_t LinAeRouteAttr);
    XCamReturn getLinAeRouteAttr(Uapi_LinAeRouteAttr_t* pLinAeRouteAttr);
    XCamReturn setHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t HdrAeRouteAttr);
    XCamReturn getHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t* pHdrAeRouteAttr);

    XCamReturn setIrisAttr(Uapi_IrisAttrV2_t IrisAttr);
    XCamReturn getIrisAttr (Uapi_IrisAttrV2_t* pIrisAttr);
    XCamReturn setSyncTestAttr(Uapi_AecSyncTest_t SyncTestAttr);
    XCamReturn getSyncTestAttr (Uapi_AecSyncTest_t* pSyncTestAttr);
    XCamReturn queryExpInfo(Uapi_ExpQueryInfo_t* pExpQueryInfo);
    XCamReturn setExpWinAttr(Uapi_ExpWin_t ExpWinAttr);
    XCamReturn getExpWinAttr(Uapi_ExpWin_t* pExpWinAttr);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAeHandle::deInit();
    };
private:

    // TODO: calibv1
    Uapi_ExpSwAttr_t  mCurExpSwAttr;
    Uapi_ExpSwAttr_t  mNewExpSwAttr;
    Uapi_LinExpAttr_t mCurLinExpAttr;
    Uapi_LinExpAttr_t mNewLinExpAttr;
    Uapi_HdrExpAttr_t mCurHdrExpAttr;
    Uapi_HdrExpAttr_t mNewHdrExpAttr;

    // TODO: calibv2
    Uapi_ExpSwAttrV2_t  mCurExpSwAttrV2;
    Uapi_ExpSwAttrV2_t  mNewExpSwAttrV2;
    Uapi_LinExpAttrV2_t mCurLinExpAttrV2;
    Uapi_LinExpAttrV2_t mNewLinExpAttrV2;
    Uapi_HdrExpAttrV2_t mCurHdrExpAttrV2;
    Uapi_HdrExpAttrV2_t mNewHdrExpAttrV2;

    Uapi_LinAeRouteAttr_t mCurLinAeRouteAttr;
    Uapi_LinAeRouteAttr_t mNewLinAeRouteAttr;
    Uapi_HdrAeRouteAttr_t mCurHdrAeRouteAttr;
    Uapi_HdrAeRouteAttr_t mNewHdrAeRouteAttr;
    Uapi_IrisAttrV2_t     mCurIrisAttr;
    Uapi_IrisAttrV2_t     mNewIrisAttr;
    Uapi_AecSyncTest_t    mCurAecSyncTestAttr;
    Uapi_AecSyncTest_t    mNewAecSyncTestAttr;
    Uapi_ExpWin_t         mCurExpWinAttr;
    Uapi_ExpWin_t         mNewExpWinAttr;

    bool updateExpSwAttr = false;
    bool updateLinExpAttr = false;
    bool updateHdrExpAttr = false;

    bool updateExpSwAttrV2 = false;
    bool updateLinExpAttrV2 = false;
    bool updateHdrExpAttrV2 = false;

    bool updateLinAeRouteAttr = false;
    bool updateHdrAeRouteAttr = false;
    bool updateIrisAttr   = false;
    bool updateSyncTestAttr = false;
    bool updateExpWinAttr = false;

    uint16_t updateAttr = 0;

    SmartPtr<RkAiqAlgoPreResAeIntShared> mPreResShared;
    SmartPtr<RkAiqAlgoProcResAeIntShared> mProcResShared;
};

// awb
class RkAiqAwbHandleInt:
    virtual public RkAiqAwbHandle,
    virtual public RkAiqHandleIntCom {
    friend class RkAiqAwbV21HandleInt;
public:
    explicit RkAiqAwbHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAwbHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore)
        , mProcResShared(nullptr) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_wb_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_wb_attrib_t));
        memset(&mCurWbV20Attr, 0, sizeof(mCurWbV20Attr));
        mCurWbOpModeAttr = RK_AIQ_WB_MODE_MAX;
        memset(&mCurWbMwbAttr, 0, sizeof(mCurWbMwbAttr));
        memset(&mCurWbAwbAttr, 0, sizeof(mCurWbAwbAttr));
        memset(&mCurWbAwbWbGainAdjustAttr, 0, sizeof(mCurWbAwbWbGainAdjustAttr));
        memset(&mCurWbAwbWbGainOffsetAttr, 0, sizeof(mCurWbAwbWbGainOffsetAttr));
        memset(&mCurWbAwbMultiWindowAttr, 0, sizeof(mCurWbAwbMultiWindowAttr));
        memset(&mNewWbV20Attr, 0, sizeof(mNewWbV20Attr));
        mNewWbOpModeAttr = RK_AIQ_WB_MODE_MAX;
        memset(&mNewWbMwbAttr, 0, sizeof(mNewWbMwbAttr));
        memset(&mNewWbAwbAttr, 0, sizeof(mNewWbAwbAttr));
        memset(&mNewWbAwbWbGainAdjustAttr, 0, sizeof(mNewWbAwbWbGainAdjustAttr));
        memset(&mNewWbAwbWbGainOffsetAttr, 0, sizeof(mNewWbAwbWbGainOffsetAttr));
        memset(&mNewWbAwbMultiWindowAttr, 0, sizeof(mNewWbAwbMultiWindowAttr));
        updateWbV20Attr = false;
        updateWbOpModeAttr = false;
        updateWbMwbAttr = false;
        updateWbAwbAttr = false;
        updateWbAwbWbGainAdjustAttr = false;
        updateWbAwbWbGainOffsetAttr = false;
        updateWbAwbMultiWindowAttr = false;
    };
    virtual ~RkAiqAwbHandleInt() {
        RkAiqAwbHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_wb_attrib_t att);
    XCamReturn getAttrib(rk_aiq_wb_attrib_t *att);
    XCamReturn getCct(rk_aiq_wb_cct_t *cct);
    XCamReturn queryWBInfo(rk_aiq_wb_querry_info_t *wb_querry_info );
    XCamReturn lock();
    XCamReturn unlock();
    XCamReturn setWbV20Attrib(rk_aiq_uapiV2_wbV20_attrib_t att);
    XCamReturn getWbV20Attrib(rk_aiq_uapiV2_wbV20_attrib_t *att);
    XCamReturn setWbOpModeAttrib(rk_aiq_wb_op_mode_t att);
    XCamReturn getWbOpModeAttrib(rk_aiq_wb_op_mode_t *att);
    XCamReturn setMwbAttrib(rk_aiq_wb_mwb_attrib_t att);
    XCamReturn getMwbAttrib(rk_aiq_wb_mwb_attrib_t *att);
    XCamReturn setAwbV20Attrib(rk_aiq_uapiV2_wbV20_awb_attrib_t att);
    XCamReturn getAwbV20Attrib(rk_aiq_uapiV2_wbV20_awb_attrib_t *att);
    XCamReturn setWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t att);
    XCamReturn getWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *att);
    XCamReturn setWbAwbWbGainOffsetAttrib(CalibDbV2_Awb_gain_offset_cfg_t att);
    XCamReturn getWbAwbWbGainOffsetAttrib(CalibDbV2_Awb_gain_offset_cfg_t *att);
    XCamReturn setWbAwbMultiWindowAttrib(CalibDbV2_Awb_Mul_Win_t att);
    XCamReturn getWbAwbMultiWindowAttrib(CalibDbV2_Awb_Mul_Win_t *att);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAwbHandle::deInit();
    };
private:
    // TODO
    rk_aiq_wb_attrib_t mCurAtt;
    rk_aiq_wb_attrib_t mNewAtt;
    //v2
    rk_aiq_uapiV2_wbV20_attrib_t mCurWbV20Attr;//v21 todo
    rk_aiq_uapiV2_wbV20_attrib_t mNewWbV20Attr;
    rk_aiq_wb_op_mode_t  mCurWbOpModeAttr;
    rk_aiq_wb_op_mode_t  mNewWbOpModeAttr;
    rk_aiq_wb_mwb_attrib_t  mCurWbMwbAttr;
    rk_aiq_wb_mwb_attrib_t  mNewWbMwbAttr;
    rk_aiq_uapiV2_wbV20_awb_attrib_t  mCurWbAwbAttr;
    rk_aiq_uapiV2_wbV20_awb_attrib_t  mNewWbAwbAttr;
    rk_aiq_uapiV2_wb_awb_wbGainAdjust_t mCurWbAwbWbGainAdjustAttr;
    rk_aiq_uapiV2_wb_awb_wbGainAdjust_t mNewWbAwbWbGainAdjustAttr;
    CalibDbV2_Awb_gain_offset_cfg_t mCurWbAwbWbGainOffsetAttr;
    CalibDbV2_Awb_gain_offset_cfg_t mNewWbAwbWbGainOffsetAttr;
    CalibDbV2_Awb_Mul_Win_t mCurWbAwbMultiWindowAttr;
    CalibDbV2_Awb_Mul_Win_t mNewWbAwbMultiWindowAttr;
    bool updateWbV20Attr;
    bool updateWbOpModeAttr;
    bool updateWbMwbAttr;
    bool updateWbAwbAttr;
    bool updateWbAwbWbGainAdjustAttr;
    bool updateWbAwbWbGainOffsetAttr;
    bool updateWbAwbMultiWindowAttr;
    SmartPtr<RkAiqAlgoProcResAwbIntShared> mProcResShared;
};

// af
class RkAiqAfHandleInt:
    virtual public RkAiqAfHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAfHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAfHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore)
        , mProcResShared(nullptr) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_af_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_af_attrib_t));
    };
    virtual ~RkAiqAfHandleInt() {
        RkAiqAfHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_af_attrib_t *att);
    XCamReturn getAttrib(rk_aiq_af_attrib_t *att);
    XCamReturn lock();
    XCamReturn unlock();
    XCamReturn Oneshot();
    XCamReturn ManualTriger();
    XCamReturn Tracking();
    XCamReturn setZoomPos(int zoom_pos);
    XCamReturn GetSearchPath(rk_aiq_af_sec_path_t* path);
    XCamReturn GetSearchResult(rk_aiq_af_result_t* result);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAfHandle::deInit();
    };
private:
    // TODO
    rk_aiq_af_attrib_t mCurAtt;
    rk_aiq_af_attrib_t mNewAtt;
    bool isUpdateAttDone;

    SmartPtr<RkAiqAlgoProcResAfIntShared> mProcResShared;
};

class RkAiqAdebayerHandleInt:
    virtual public RkAiqAdebayerHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAdebayerHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAdebayerHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {};
    virtual ~RkAiqAdebayerHandleInt() {
        RkAiqAdebayerHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(adebayer_attrib_t att);
    XCamReturn getAttrib(adebayer_attrib_t *att);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAdebayerHandle::deInit();
    };
private:
    adebayer_attrib_t mCurAtt;
    adebayer_attrib_t mNewAtt;
};

// amerge
class RkAiqAmergeHandleInt:
    virtual public RkAiqAmergeHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAmergeHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAmergeHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {}
    virtual ~RkAiqAmergeHandleInt() {
        RkAiqAmergeHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    XCamReturn setAttrib(amerge_attrib_t att);
    XCamReturn getAttrib(amerge_attrib_t* att);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAmergeHandle::deInit();
    };
private:
    amerge_attrib_t mCurAtt;
    amerge_attrib_t mNewAtt;
};

// atmo
class RkAiqAtmoHandleInt:
    virtual public RkAiqAtmoHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAtmoHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAtmoHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {}
    virtual ~RkAiqAtmoHandleInt() {
        RkAiqAtmoHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    XCamReturn setAttrib(atmo_attrib_t att);
    XCamReturn getAttrib(atmo_attrib_t* att);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAtmoHandle::deInit();
    };
private:
    atmo_attrib_t mCurAtt;
    atmo_attrib_t mNewAtt;
};

class RkAiqAgicHandleInt:
    virtual public RkAiqAgicHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAgicHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAgicHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {};
    virtual ~RkAiqAgicHandleInt() {
        RkAiqAgicHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    XCamReturn setAttrib(agic_attrib_t att);
    XCamReturn getAttrib(agic_attrib_t *att);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAgicHandle::deInit();
    };
private:
    agic_attrib_t mCurAtt;
    agic_attrib_t mNewAtt;
};

// adehaze
class RkAiqAdhazHandleInt:
    virtual public RkAiqAdhazHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAdhazHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAdhazHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {};
    virtual ~RkAiqAdhazHandleInt() {
        RkAiqAdhazHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setSwAttrib(adehaze_sw_s att);
    XCamReturn getSwAttrib(adehaze_sw_s *att);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAdhazHandle::deInit();
    };
private:
    // TODO
    adehaze_sw_V2_t mCurAtt;
    adehaze_sw_V2_t mNewAtt;
};


// agamma
class RkAiqAgammaHandleInt:
    virtual public RkAiqAgammaHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAgammaHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAgammaHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_gamma_attrib_V2_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_gamma_attrib_V2_t));
    };
    virtual ~RkAiqAgammaHandleInt() {
        RkAiqAgammaHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_gamma_attrib_V2_t att);
    XCamReturn getAttrib(rk_aiq_gamma_attrib_V2_t *att);
    //XCamReturn queryLscInfo(rk_aiq_lsc_querry_info_t *lsc_querry_info );

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAgammaHandle::deInit();
    };
private:
    // TODO
    rk_aiq_gamma_attrib_V2_t mCurAtt;
    rk_aiq_gamma_attrib_V2_t mNewAtt;
};

// adegamma
class RkAiqAdegammaHandleInt:
    virtual public RkAiqAdegammaHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAdegammaHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAdegammaHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_degamma_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_degamma_attrib_t));
    };
    virtual ~RkAiqAdegammaHandleInt() {
        RkAiqAdegammaHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_degamma_attrib_t att);
    XCamReturn getAttrib(rk_aiq_degamma_attrib_t *att);
    //XCamReturn queryLscInfo(rk_aiq_lsc_querry_info_t *lsc_querry_info );

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAdegammaHandle::deInit();
    };
private:
    // TODO
    rk_aiq_degamma_attrib_t mCurAtt;
    rk_aiq_degamma_attrib_t mNewAtt;
};

// alsc
class RkAiqAlscHandleInt:
    virtual public RkAiqAlscHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAlscHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAlscHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_lsc_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_lsc_attrib_t));
    };
    virtual ~RkAiqAlscHandleInt() {
        RkAiqAlscHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_lsc_attrib_t att);
    XCamReturn getAttrib(rk_aiq_lsc_attrib_t *att);
    XCamReturn queryLscInfo(rk_aiq_lsc_querry_info_t *lsc_querry_info );

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAlscHandle::deInit();
    };
private:
    // TODO
    rk_aiq_lsc_attrib_t mCurAtt;
    rk_aiq_lsc_attrib_t mNewAtt;
};

// accm
class RkAiqAccmHandleInt:
    virtual public RkAiqAccmHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAccmHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAccmHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_ccm_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_ccm_attrib_t));
    };
    virtual ~RkAiqAccmHandleInt() {
        RkAiqAccmHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_ccm_attrib_t att);
    XCamReturn getAttrib(rk_aiq_ccm_attrib_t *att);
    XCamReturn queryCcmInfo(rk_aiq_ccm_querry_info_t *ccm_querry_info );

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAccmHandle::deInit();
    };
private:
    // TODO
    rk_aiq_ccm_attrib_t mCurAtt;
    rk_aiq_ccm_attrib_t mNewAtt;
};

// a3dlut
class RkAiqA3dlutHandleInt:
    virtual public RkAiqA3dlutHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqA3dlutHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqA3dlutHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_lut3d_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_lut3d_attrib_t));
    };
    virtual ~RkAiqA3dlutHandleInt() {
        RkAiqA3dlutHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_lut3d_attrib_t att);
    XCamReturn getAttrib(rk_aiq_lut3d_attrib_t *att);
    XCamReturn query3dlutInfo(rk_aiq_lut3d_querry_info_t *lut3d_querry_info );

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqA3dlutHandle::deInit();
    };
private:
    // TODO
    rk_aiq_lut3d_attrib_t mCurAtt;
    rk_aiq_lut3d_attrib_t mNewAtt;
};




class RkAiqAblcHandleInt:
    virtual public RkAiqAblcHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAblcHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAblcHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_blc_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_blc_attrib_t));
    };
    virtual ~RkAiqAblcHandleInt() {
        RkAiqAblcHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_blc_attrib_t *att);
    XCamReturn getAttrib(rk_aiq_blc_attrib_t *att);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAblcHandle::deInit();
    };
private:
    // TODO
    rk_aiq_blc_attrib_t mCurAtt;
    rk_aiq_blc_attrib_t mNewAtt;
};




// adpcc
class RkAiqAdpccHandleInt:
    virtual public RkAiqAdpccHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAdpccHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAdpccHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_dpcc_attrib_V20_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_dpcc_attrib_V20_t));
    };
    virtual ~RkAiqAdpccHandleInt() {
        RkAiqAdpccHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_dpcc_attrib_V20_t *att);
    XCamReturn getAttrib(rk_aiq_dpcc_attrib_V20_t *att);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAdpccHandle::deInit();
    };
private:
    // TODO
    rk_aiq_dpcc_attrib_V20_t mCurAtt;
    rk_aiq_dpcc_attrib_V20_t mNewAtt;
};


// anr
class RkAiqAnrHandleInt:
    virtual public RkAiqAnrHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAnrHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAnrHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_nr_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_nr_attrib_t));
    };
    virtual ~RkAiqAnrHandleInt() {
        RkAiqAnrHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_nr_attrib_t *att);
    XCamReturn getAttrib(rk_aiq_nr_attrib_t *att);
    XCamReturn setLumaSFStrength(float fPercent);
    XCamReturn setLumaTFStrength(float fPercent);
    XCamReturn getLumaSFStrength(float *pPercent);
    XCamReturn getLumaTFStrength(float *pPercent);
    XCamReturn setChromaSFStrength(float fPercent);
    XCamReturn setChromaTFStrength(float fPercent);
    XCamReturn getChromaSFStrength(float *pPercent);
    XCamReturn getChromaTFStrength(float *pPercent);
    XCamReturn setRawnrSFStrength(float fPercent);
    XCamReturn getRawnrSFStrength(float *pPercent);
    XCamReturn setIQPara(rk_aiq_nr_IQPara_t *pPara);
    XCamReturn getIQPara(rk_aiq_nr_IQPara_t *pPara);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAnrHandle::deInit();
    };
private:
    // TODO
    rk_aiq_nr_attrib_t mCurAtt;
    rk_aiq_nr_attrib_t mNewAtt;
    rk_aiq_nr_IQPara_t mCurIQpara;
    rk_aiq_nr_IQPara_t mNewIQpara;
    bool UpdateIQpara = false;
};


// anr
class RkAiqAsharpHandleInt:
    virtual public RkAiqAsharpHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAsharpHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAsharpHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_sharp_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_sharp_attrib_t));
    };
    virtual ~RkAiqAsharpHandleInt() {
        RkAiqAsharpHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_sharp_attrib_t *att);
    XCamReturn getAttrib(rk_aiq_sharp_attrib_t *att);
    XCamReturn setStrength(float fPercent);
    XCamReturn getStrength(float *pPercent);
    XCamReturn setIQPara(rk_aiq_sharp_IQpara_t *para);
    XCamReturn getIQPara(rk_aiq_sharp_IQpara_t *para);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAsharpHandle::deInit();
    };
private:
    // TODO
    rk_aiq_sharp_attrib_t mCurAtt;
    rk_aiq_sharp_attrib_t mNewAtt;
    rk_aiq_sharp_IQpara_t mCurIQPara;
    rk_aiq_sharp_IQpara_t mNewIQPara;
    bool updateIQpara = false;

};

// afec
class RkAiqAfecHandleInt:
    virtual public RkAiqAfecHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAfecHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAfecHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_fec_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_fec_attrib_t));
        mCurAtt.en = 0xff;
    };
    virtual ~RkAiqAfecHandleInt() {
        RkAiqAfecHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();

    XCamReturn setAttrib(rk_aiq_fec_attrib_t att);
    XCamReturn getAttrib(rk_aiq_fec_attrib_t *att);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAfecHandle::deInit();
    };
private:
    rk_aiq_fec_attrib_t mCurAtt;
    rk_aiq_fec_attrib_t mNewAtt;
};

class RkAiqAsdHandleInt:
    virtual public RkAiqAsdHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAsdHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAsdHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {};
    virtual ~RkAiqAsdHandleInt() {
        RkAiqAsdHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(asd_attrib_t att);
    XCamReturn getAttrib(asd_attrib_t *att);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAsdHandle::deInit();
    };
private:
    asd_attrib_t mCurAtt;
    asd_attrib_t mNewAtt;
};

// aldch
class RkAiqAldchHandleInt:
    virtual public RkAiqAldchHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAldchHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAldchHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_ldch_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_ldch_attrib_t));
    };
    virtual ~RkAiqAldchHandleInt() {
        RkAiqAldchHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();

    XCamReturn setAttrib(rk_aiq_ldch_attrib_t att);
    XCamReturn getAttrib(rk_aiq_ldch_attrib_t *att);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAldchHandle::deInit();
    };
private:
    rk_aiq_ldch_attrib_t mCurAtt;
    rk_aiq_ldch_attrib_t mNewAtt;
};

class RkAiqAcpHandleInt:
    virtual public RkAiqAcpHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAcpHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAcpHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {};
    virtual ~RkAiqAcpHandleInt() {
        RkAiqAcpHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    XCamReturn setAttrib(acp_attrib_t att);
    XCamReturn getAttrib(acp_attrib_t *att);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAcpHandle::deInit();
    };
private:
    acp_attrib_t mCurAtt;
    acp_attrib_t mNewAtt;
};

class RkAiqAdrcHandleInt:
    virtual public RkAiqAdrcHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAdrcHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAdrcHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {};
    virtual ~RkAiqAdrcHandleInt() {
        RkAiqAdrcHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    XCamReturn setAttrib(drc_attrib_t att);
    XCamReturn getAttrib(drc_attrib_t *att);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAdrcHandle::deInit();
    };
private:
    drc_attrib_t mCurAtt;
    drc_attrib_t mNewAtt;
};
class RkAiqAieHandleInt:
    virtual public RkAiqAieHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAieHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAieHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {};
    virtual ~RkAiqAieHandleInt() {
        RkAiqAieHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    XCamReturn setAttrib(aie_attrib_t att);
    XCamReturn getAttrib(aie_attrib_t *att);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAieHandle::deInit();
    };
private:
    aie_attrib_t mCurAtt;
    aie_attrib_t mNewAtt;
};

// aeis
class RkAiqAeisHandleInt:
    virtual public RkAiqAeisHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAeisHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAeisHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_eis_attrib_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_eis_attrib_t));
        mCurAtt.en = 0xff;
    };
    virtual ~RkAiqAeisHandleInt() {
        RkAiqAeisHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();

    XCamReturn setAttrib(rk_aiq_eis_attrib_t att);
    XCamReturn getAttrib(rk_aiq_eis_attrib_t *att);

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAeisHandle::deInit();
    };
private:
    rk_aiq_eis_attrib_t mCurAtt;
    rk_aiq_eis_attrib_t mNewAtt;
};

//amd
class RkAiqAmdHandleInt:
    virtual public RkAiqAmdHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAmdHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAmdHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore)
        , mProcResShared(nullptr) {};
    virtual ~RkAiqAmdHandleInt() {
        RkAiqAmdHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAmdHandle::deInit();
    };
private:
    SmartPtr<RkAiqAlgoProcResAmdIntShared> mProcResShared;
};





// aynr v1
class RkAiqArawnrHandleInt:
    virtual public RkAiqArawnrHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqArawnrHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqArawnrHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_bayernr_attrib_v1_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_bayernr_attrib_v1_t));
    };
    virtual ~RkAiqArawnrHandleInt() {
        RkAiqArawnrHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_bayernr_attrib_v1_t *att);
    XCamReturn getAttrib(rk_aiq_bayernr_attrib_v1_t *att);
    XCamReturn setStrength(float fPercent);
    XCamReturn getStrength(float *pPercent);
    XCamReturn setIQPara(rk_aiq_bayernr_IQPara_V1_t *pPara);
    XCamReturn getIQPara(rk_aiq_bayernr_IQPara_V1_t *pPara);
    XCamReturn setJsonPara(rk_aiq_bayernr_JsonPara_V1_t *para);
    XCamReturn getJsonPara(rk_aiq_bayernr_JsonPara_V1_t *para);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqArawnrHandle::deInit();
    };
private:
    // TODO
    rk_aiq_bayernr_attrib_v1_t mCurAtt;
    rk_aiq_bayernr_attrib_v1_t mNewAtt;
    rk_aiq_bayernr_IQPara_V1_t mCurIQPara;
    rk_aiq_bayernr_IQPara_V1_t mNewIQPara;
    rk_aiq_bayernr_JsonPara_V1_t mCurJsonPara;
    rk_aiq_bayernr_JsonPara_V1_t mNewJsonPara;
    bool updateIQpara = false;
    bool updateJsonpara = false;
};


// aynr v1
class RkAiqAynrHandleInt:
    virtual public RkAiqAynrHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAynrHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAynrHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_ynr_attrib_v1_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_ynr_attrib_v1_t));
    };
    virtual ~RkAiqAynrHandleInt() {
        RkAiqAynrHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_ynr_attrib_v1_t *att);
    XCamReturn getAttrib(rk_aiq_ynr_attrib_v1_t *att);
    XCamReturn setStrength(float fPercent);
    XCamReturn getStrength(float *pPercent);
    XCamReturn setIQPara(rk_aiq_ynr_IQPara_V1_t *pPara);
    XCamReturn getIQPara(rk_aiq_ynr_IQPara_V1_t *pPara);
    XCamReturn setJsonPara(rk_aiq_ynr_JsonPara_V1_t *para);
    XCamReturn getJsonPara(rk_aiq_ynr_JsonPara_V1_t *para);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAynrHandle::deInit();
    };
private:
    // TODO
    rk_aiq_ynr_attrib_v1_t mCurAtt;
    rk_aiq_ynr_attrib_v1_t mNewAtt;
    rk_aiq_ynr_IQPara_V1_t mCurIQPara;
    rk_aiq_ynr_IQPara_V1_t mNewIQPara;
    rk_aiq_ynr_JsonPara_V1_t mCurJsonPara;
    rk_aiq_ynr_JsonPara_V1_t mNewJsonPara;
    bool updateIQpara = false;
    bool updateJsonpara = false;
};






// auvnr v1
class RkAiqAcnrHandleInt:
    virtual public RkAiqAcnrHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAcnrHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAcnrHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_uvnr_attrib_v1_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_uvnr_attrib_v1_t));
    };
    virtual ~RkAiqAcnrHandleInt() {
        RkAiqAcnrHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    // TODO add algo specific methords, this is a sample
    XCamReturn setAttrib(rk_aiq_uvnr_attrib_v1_t *att);
    XCamReturn getAttrib(rk_aiq_uvnr_attrib_v1_t *att);
    XCamReturn setStrength(float fPercent);
    XCamReturn getStrength(float *pPercent);
    XCamReturn setIQPara(rk_aiq_uvnr_IQPara_v1_t *pPara);
    XCamReturn getIQPara(rk_aiq_uvnr_IQPara_v1_t *pPara);
    XCamReturn setJsonPara(rk_aiq_uvnr_JsonPara_v1_t *para);
    XCamReturn getJsonPara(rk_aiq_uvnr_JsonPara_v1_t *para);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAcnrHandle::deInit();
    };
private:
    // TODO
    rk_aiq_uvnr_attrib_v1_t mCurAtt;
    rk_aiq_uvnr_attrib_v1_t mNewAtt;
    rk_aiq_uvnr_IQPara_v1_t mCurIQPara;
    rk_aiq_uvnr_IQPara_v1_t mNewIQPara;
    rk_aiq_uvnr_JsonPara_v1_t mCurJsonPara;
    rk_aiq_uvnr_JsonPara_v1_t mNewJsonPara;
    bool updateIQpara = false;
    bool updateJsonpara = false;
};

class RkAiqAmfnrHandleInt:
    virtual public RkAiqAmfnrHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAmfnrHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAmfnrHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
        memset(&mCurAtt, 0, sizeof(rk_aiq_mfnr_attrib_v1_t));
        memset(&mNewAtt, 0, sizeof(rk_aiq_mfnr_attrib_v1_t));
        memset(&mCurIQPara, 0, sizeof(rk_aiq_mfnr_IQPara_V1_t));
        memset(&mNewIQPara, 0, sizeof(rk_aiq_mfnr_IQPara_V1_t));
        memset(&mCurJsonPara, 0, sizeof(rk_aiq_mfnr_JsonPara_V1_t));
        memset(&mNewJsonPara, 0, sizeof(rk_aiq_mfnr_JsonPara_V1_t));
    };
    virtual ~RkAiqAmfnrHandleInt() {
        RkAiqAmfnrHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();
    XCamReturn setAttrib(rk_aiq_mfnr_attrib_v1_t *att);
    XCamReturn getAttrib(rk_aiq_mfnr_attrib_v1_t *att);
    XCamReturn setLumaStrength(float fPercent);
    XCamReturn getLumaStrength(float *pPercent);
    XCamReturn setChromaStrength(float fPercent);
    XCamReturn getChromaStrength(float *pPercent);
    XCamReturn setIQPara(rk_aiq_mfnr_IQPara_V1_t *pPara);
    XCamReturn getIQPara(rk_aiq_mfnr_IQPara_V1_t *pPara);
    XCamReturn setJsonPara(rk_aiq_mfnr_JsonPara_V1_t *para);
    XCamReturn getJsonPara(rk_aiq_mfnr_JsonPara_V1_t *para);
protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAmfnrHandle::deInit();
    };
private:
    rk_aiq_mfnr_attrib_v1_t mCurAtt;
    rk_aiq_mfnr_attrib_v1_t mNewAtt;
    rk_aiq_mfnr_IQPara_V1_t mCurIQPara;
    rk_aiq_mfnr_IQPara_V1_t mNewIQPara;
    rk_aiq_mfnr_JsonPara_V1_t mCurJsonPara;
    rk_aiq_mfnr_JsonPara_V1_t mNewJsonPara;
    bool updateIQpara = false;
    bool updateJsonpara = false;
};


// again v1
class RkAiqAgainHandleInt:
    virtual public RkAiqAgainHandle,
    virtual public RkAiqHandleIntCom {
public:
    explicit RkAiqAgainHandleInt(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
        : RkAiqHandle(des, aiqCore)
        , RkAiqAgainHandle(des, aiqCore)
        , RkAiqHandleIntCom(des, aiqCore) {
    };
    virtual ~RkAiqAgainHandleInt() {
        RkAiqAgainHandle::deInit();
    };
    virtual XCamReturn updateConfig(bool needSync);
    virtual XCamReturn prepare();
    virtual XCamReturn preProcess();
    virtual XCamReturn processing();
    virtual XCamReturn postProcess();

protected:
    virtual void init();
    virtual void deInit() {
        RkAiqAgainHandle::deInit();
    };
private:


};

}; //namespace RkCam

#endif