/*
|
* 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.
|
*/
|
#ifndef _RK_AIQ_CAMGROUP_HANDLE_INT_V3_H_
|
#define _RK_AIQ_CAMGROUP_HANDLE_INT_V3_H_
|
|
#include "RkAiqCamgroupHandle.h"
|
#include "ae/rk_aiq_uapi_ae_int.h"
|
#include "awb/rk_aiq_uapiv2_camgroup_awb_int.h"
|
#include "accm/rk_aiq_uapi_accm_int.h"
|
#include "a3dlut/rk_aiq_uapi_a3dlut_int.h"
|
#include "agamma/rk_aiq_uapi_agamma_int.h"
|
#include "amerge/rk_aiq_uapi_amerge_int.h"
|
#include "adrc/rk_aiq_uapi_adrc_int.h"
|
#include "adehaze/rk_aiq_uapi_adehaze_int.h"
|
#include "algo_camgroup_handlers/RkAiqCamGroupAgicHandle.h"
|
#include "aynr3/rk_aiq_uapi_aynr_int_v3.h"
|
#include "acnr2/rk_aiq_uapi_acnr_int_v2.h"
|
#include "abayer2dnr2/rk_aiq_uapi_abayer2dnr_int_v2.h"
|
#include "ablc/rk_aiq_uapi_ablc_int.h"
|
#include "aldch/rk_aiq_uapi_aldch_int.h"
|
#include "adebayer/rk_aiq_uapi_adebayer_int.h"
|
#include "alsc/rk_aiq_uapi_alsc_int.h"
|
#include "adpcc/rk_aiq_uapi_adpcc_int.h"
|
|
namespace RkCam {
|
// ae
|
class RkAiqCamGroupAeHandleInt:
|
public RkAiqCamgroupHandle {
|
|
public:
|
explicit RkAiqCamGroupAeHandleInt(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurExpSwAttrV2, 0, sizeof(Uapi_ExpSwAttrV2_t));
|
memset(&mNewExpSwAttrV2, 0, sizeof(Uapi_ExpSwAttrV2_t));
|
memset(&mCurLinExpAttrV2, 0, sizeof(Uapi_LinExpAttrV2_t));
|
memset(&mNewLinExpAttrV2, 0, sizeof(Uapi_LinExpAttrV2_t));
|
memset(&mCurHdrExpAttrV2, 0, sizeof(Uapi_HdrExpAttrV2_t));
|
memset(&mNewHdrExpAttrV2, 0, sizeof(Uapi_HdrExpAttrV2_t));
|
|
memset(&mCurLinAeRouteAttr, 0, sizeof(Uapi_LinAeRouteAttr_t));
|
memset(&mNewLinAeRouteAttr, 0, sizeof(Uapi_LinAeRouteAttr_t));
|
memset(&mCurHdrAeRouteAttr, 0, sizeof(Uapi_HdrAeRouteAttr_t));
|
memset(&mNewHdrAeRouteAttr, 0, sizeof(Uapi_HdrAeRouteAttr_t));
|
memset(&mCurAecSyncTestAttr, 0, sizeof(Uapi_AecSyncTest_t));
|
memset(&mNewAecSyncTestAttr, 0, sizeof(Uapi_AecSyncTest_t));
|
|
updateExpSwAttrV2 = false;
|
updateLinExpAttrV2 = false;
|
updateHdrExpAttrV2 = false;
|
updateLinAeRouteAttr = false;
|
updateHdrAeRouteAttr = false;
|
updateSyncTestAttr = false;
|
|
};
|
virtual ~RkAiqCamGroupAeHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
|
// 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 setSyncTestAttr(Uapi_AecSyncTest_t SyncTestAttr);
|
XCamReturn getSyncTestAttr (Uapi_AecSyncTest_t* pSyncTestAttr);
|
XCamReturn queryExpInfo(Uapi_ExpQueryInfo_t* pExpQueryInfo);
|
|
protected:
|
|
private:
|
|
// 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_AecSyncTest_t mCurAecSyncTestAttr;
|
Uapi_AecSyncTest_t mNewAecSyncTestAttr;
|
|
mutable std::atomic<bool> updateExpSwAttrV2;
|
mutable std::atomic<bool> updateLinExpAttrV2;
|
mutable std::atomic<bool> updateHdrExpAttrV2;
|
|
mutable std::atomic<bool> updateLinAeRouteAttr;
|
mutable std::atomic<bool> updateHdrAeRouteAttr;
|
mutable std::atomic<bool> updateSyncTestAttr;
|
};
|
|
// awb
|
class RkAiqCamGroupAwbHandleInt:
|
public RkAiqCamgroupHandle {
|
|
public:
|
explicit RkAiqCamGroupAwbHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurWbV21Attr, 0, sizeof(mCurWbV21Attr));
|
memset(&mCurWbOpModeAttr, 0, sizeof(mCurWbOpModeAttr));
|
mCurWbOpModeAttr.mode = 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(&mNewWbV21Attr, 0, sizeof(mNewWbV21Attr));
|
memset(&mNewWbOpModeAttr, 0, sizeof(mNewWbOpModeAttr));
|
mNewWbOpModeAttr.mode = 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));
|
updateWbV21Attr = false;
|
updateWbOpModeAttr = false;
|
updateWbMwbAttr = false;
|
updateWbAwbAttr = false;
|
updateWbAwbWbGainAdjustAttr = false;
|
updateWbAwbWbGainOffsetAttr = false;
|
updateWbAwbMultiWindowAttr = false;
|
};
|
virtual ~RkAiqCamGroupAwbHandleInt() {
|
// free wbGainAdjust.lutAll from rk_aiq_uapiV2_awb_GetAwbGainAdjust in rk_aiq_uapiv2_awb_int.cpp
|
for(int i = 0; i < mNewWbV21Attr.stAuto.wbGainAdjust.lutAll_len; i++) {
|
if(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].cri_lut_out) {
|
free(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].cri_lut_out);
|
mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].cri_lut_out = NULL;
|
}
|
if(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].ct_lut_out) {
|
free(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].ct_lut_out);
|
mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].ct_lut_out = NULL;
|
}
|
}
|
if (mNewWbV21Attr.stAuto.wbGainAdjust.lutAll) {
|
free(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll);
|
mNewWbV21Attr.stAuto.wbGainAdjust.lutAll = NULL;
|
}
|
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
|
XCamReturn setWbV21Attrib(rk_aiq_uapiV2_wbV21_attrib_t att);
|
XCamReturn getWbV21Attrib(rk_aiq_uapiV2_wbV21_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 setWbOpModeAttrib(rk_aiq_uapiV2_wb_opMode_t att);
|
XCamReturn getWbOpModeAttrib(rk_aiq_uapiV2_wb_opMode_t *att);
|
XCamReturn setMwbAttrib(rk_aiq_wb_mwb_attrib_t att);
|
XCamReturn getMwbAttrib(rk_aiq_wb_mwb_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(rk_aiq_uapiV2_wb_awb_wbGainOffset_t att);
|
XCamReturn getWbAwbWbGainOffsetAttrib(rk_aiq_uapiV2_wb_awb_wbGainOffset_t *att);
|
XCamReturn setWbAwbMultiWindowAttrib(rk_aiq_uapiV2_wb_awb_mulWindow_t att);
|
XCamReturn getWbAwbMultiWindowAttrib(rk_aiq_uapiV2_wb_awb_mulWindow_t *att);
|
XCamReturn getAlgoStat(rk_tool_awb_stat_res_full_t *awb_stat_algo);
|
XCamReturn getStrategyResult(rk_tool_awb_strategy_result_t *awb_strategy_result);
|
|
protected:
|
|
private:
|
// TODO
|
rk_aiq_uapiV2_wbV21_attrib_t mCurWbV21Attr;
|
rk_aiq_uapiV2_wbV21_attrib_t mNewWbV21Attr;
|
rk_aiq_uapiV2_wb_opMode_t mCurWbOpModeAttr;
|
rk_aiq_uapiV2_wb_opMode_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;
|
rk_aiq_uapiV2_wb_awb_wbGainOffset_t mCurWbAwbWbGainOffsetAttr;
|
rk_aiq_uapiV2_wb_awb_wbGainOffset_t mNewWbAwbWbGainOffsetAttr;
|
rk_aiq_uapiV2_wb_awb_mulWindow_t mCurWbAwbMultiWindowAttr;
|
rk_aiq_uapiV2_wb_awb_mulWindow_t mNewWbAwbMultiWindowAttr;
|
mutable std::atomic<bool> updateWbV21Attr;
|
mutable std::atomic<bool> updateWbOpModeAttr;
|
mutable std::atomic<bool> updateWbMwbAttr;
|
mutable std::atomic<bool> updateWbAwbAttr;
|
mutable std::atomic<bool> updateWbAwbWbGainAdjustAttr;
|
mutable std::atomic<bool> updateWbAwbWbGainOffsetAttr;
|
mutable std::atomic<bool> updateWbAwbMultiWindowAttr;
|
};
|
|
// accm
|
class RkAiqCamGroupAccmHandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAccmHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(rk_aiq_ccm_attrib_t));
|
memset(&mNewAtt, 0, sizeof(rk_aiq_ccm_attrib_t));
|
};
|
virtual ~RkAiqCamGroupAccmHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
// 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:
|
|
private:
|
// TODO
|
rk_aiq_ccm_attrib_t mCurAtt;
|
rk_aiq_ccm_attrib_t mNewAtt;
|
};
|
|
// a3dlut
|
class RkAiqCamGroupA3dlutHandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupA3dlutHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(rk_aiq_lut3d_attrib_t));
|
memset(&mNewAtt, 0, sizeof(rk_aiq_lut3d_attrib_t));
|
};
|
virtual ~RkAiqCamGroupA3dlutHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
// 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:
|
|
private:
|
// TODO
|
rk_aiq_lut3d_attrib_t mCurAtt;
|
rk_aiq_lut3d_attrib_t mNewAtt;
|
};
|
|
// agamma
|
class RkAiqCamGroupAgammaHandleInt:
|
virtual public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAgammaHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(rk_aiq_gamma_attr_t));
|
memset(&mNewAtt, 0, sizeof(rk_aiq_gamma_attr_t));
|
};
|
virtual ~RkAiqCamGroupAgammaHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
// TODO add algo specific methords, this is a sample
|
XCamReturn setAttrib(rk_aiq_gamma_attr_t att);
|
XCamReturn getAttrib(rk_aiq_gamma_attr_t *att);
|
|
protected:
|
|
private:
|
// TODO
|
rk_aiq_gamma_attr_t mCurAtt;
|
rk_aiq_gamma_attr_t mNewAtt;
|
};
|
|
// amerge
|
class RkAiqCamGroupAmergeHandleInt:
|
virtual public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAmergeHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(mergeAttr_t));
|
memset(&mNewAtt, 0, sizeof(mergeAttr_t));
|
};
|
virtual ~RkAiqCamGroupAmergeHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
// TODO add algo specific methords, this is a sample
|
XCamReturn setAttrib(mergeAttr_t att);
|
XCamReturn getAttrib(mergeAttr_t *att);
|
|
protected:
|
|
private:
|
// TODO
|
mergeAttr_t mCurAtt;
|
mergeAttr_t mNewAtt;
|
};
|
|
// adrc
|
class RkAiqCamGroupAdrcHandleInt:
|
virtual public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAdrcHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(drcAttr_t));
|
memset(&mNewAtt, 0, sizeof(drcAttr_t));
|
};
|
virtual ~RkAiqCamGroupAdrcHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
// TODO add algo specific methords, this is a sample
|
XCamReturn setAttrib(drcAttr_t att);
|
XCamReturn getAttrib(drcAttr_t *att);
|
|
protected:
|
|
private:
|
// TODO
|
drcAttr_t mCurAtt;
|
drcAttr_t mNewAtt;
|
};
|
|
// adehaze
|
class RkAiqCamGroupAdhazHandleInt:
|
virtual public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAdhazHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(adehaze_sw_V2_t));
|
memset(&mNewAtt, 0, sizeof(adehaze_sw_V2_t));
|
};
|
virtual ~RkAiqCamGroupAdhazHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
XCamReturn setAttrib(adehaze_sw_V2_t att);
|
XCamReturn getAttrib(adehaze_sw_V2_t *att);
|
protected:
|
|
private:
|
// TODO
|
adehaze_sw_V2_t mCurAtt;
|
adehaze_sw_V2_t mNewAtt;
|
};
|
|
|
// aynr
|
class RkAiqCamGroupAynrV3HandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAynrV3HandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
updateAtt = false;
|
updateStrength = false;
|
memset(&mCurStrength, 0x00, sizeof(mCurStrength));
|
mCurStrength.percent = 1.0;
|
memset(&mNewStrength, 0x00, sizeof(mNewStrength));
|
mNewStrength.percent = 1.0;
|
memset(&mCurAtt, 0x00, sizeof(mCurAtt));
|
memset(&mNewAtt, 0x00, sizeof(mNewAtt));
|
};
|
virtual ~RkAiqCamGroupAynrV3HandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
XCamReturn setAttrib(rk_aiq_ynr_attrib_v3_t *att);
|
XCamReturn getAttrib(rk_aiq_ynr_attrib_v3_t *att);
|
XCamReturn setStrength(rk_aiq_ynr_strength_v3_t *pStrength);
|
XCamReturn getStrength(rk_aiq_ynr_strength_v3_t *pStrength);
|
|
protected:
|
|
private:
|
|
rk_aiq_ynr_attrib_v3_t mCurAtt;
|
rk_aiq_ynr_attrib_v3_t mNewAtt;
|
rk_aiq_ynr_strength_v3_t mCurStrength;
|
rk_aiq_ynr_strength_v3_t mNewStrength;
|
mutable std::atomic<bool> updateStrength;
|
};
|
|
// acnr v2
|
class RkAiqCamGroupAcnrV2HandleInt:
|
virtual public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAcnrV2HandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
updateStrength = false;
|
updateAtt = false;
|
memset(&mCurStrength, 0x00, sizeof(mCurStrength));
|
mCurStrength.percent = 1.0;
|
memset(&mNewStrength, 0x00, sizeof(mNewStrength));
|
mNewStrength.percent = 1.0;
|
memset(&mCurAtt, 0x00, sizeof(mCurAtt));
|
memset(&mNewAtt, 0x00, sizeof(mNewAtt));
|
};
|
virtual ~RkAiqCamGroupAcnrV2HandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
XCamReturn setAttrib(rk_aiq_cnr_attrib_v2_t *att);
|
XCamReturn getAttrib(rk_aiq_cnr_attrib_v2_t *att);
|
XCamReturn setStrength(rk_aiq_cnr_strength_v2_t *pStrength);
|
XCamReturn getStrength(rk_aiq_cnr_strength_v2_t *pStrength);
|
protected:
|
|
private:
|
// TODO
|
rk_aiq_cnr_attrib_v2_t mCurAtt;
|
rk_aiq_cnr_attrib_v2_t mNewAtt;
|
rk_aiq_cnr_strength_v2_t mCurStrength;
|
rk_aiq_cnr_strength_v2_t mNewStrength;
|
mutable std::atomic<bool> updateStrength;
|
};
|
|
|
// aynr v2
|
class RkAiqCamGroupAbayer2dnrV2HandleInt:
|
virtual public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAbayer2dnrV2HandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
updateStrength = false;
|
updateAtt = false;
|
memset(&mCurStrength, 0x00, sizeof(mCurStrength));
|
memset(&mNewStrength, 0x00, sizeof(mNewStrength));
|
mCurStrength.percent = 1.0;
|
mNewStrength.percent = 1.0;
|
memset(&mCurAtt, 0x00, sizeof(mCurAtt));
|
memset(&mNewAtt, 0x00, sizeof(mNewAtt));
|
|
};
|
virtual ~RkAiqCamGroupAbayer2dnrV2HandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
XCamReturn setAttrib(rk_aiq_bayer2dnr_attrib_v2_t *att);
|
XCamReturn getAttrib(rk_aiq_bayer2dnr_attrib_v2_t *att);
|
XCamReturn setStrength(rk_aiq_bayer2dnr_strength_v2_t *pStrength);
|
XCamReturn getStrength(rk_aiq_bayer2dnr_strength_v2_t *pStrength);
|
protected:
|
|
private:
|
// TODO
|
rk_aiq_bayer2dnr_attrib_v2_t mCurAtt;
|
rk_aiq_bayer2dnr_attrib_v2_t mNewAtt;
|
rk_aiq_bayer2dnr_strength_v2_t mCurStrength;
|
rk_aiq_bayer2dnr_strength_v2_t mNewStrength;
|
mutable std::atomic<bool> updateStrength;
|
};
|
|
|
// ablc
|
class RkAiqCamGroupAblcHandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAblcHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
updateAtt = false;
|
memset(&mCurAtt, 0x00, sizeof(mCurAtt));
|
memset(&mNewAtt, 0x00, sizeof(mNewAtt));
|
|
};
|
virtual ~RkAiqCamGroupAblcHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
XCamReturn setAttrib(rk_aiq_blc_attrib_t *att);
|
XCamReturn getAttrib(rk_aiq_blc_attrib_t *att);
|
protected:
|
|
private:
|
|
rk_aiq_blc_attrib_t mCurAtt;
|
rk_aiq_blc_attrib_t mNewAtt;
|
};
|
|
// asharp
|
class RkAiqCamGroupAsharpV4HandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAsharpV4HandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
updateAtt = false;
|
updateStrength = false;
|
memset(&mCurStrength, 0x00, sizeof(mCurStrength));
|
mCurStrength.percent = 1.0;
|
memset(&mNewStrength, 0x00, sizeof(mNewStrength));
|
mNewStrength.percent = 1.0;
|
memset(&mCurAtt, 0x00, sizeof(mCurAtt));
|
memset(&mNewAtt, 0x00, sizeof(mNewAtt));
|
|
};
|
virtual ~RkAiqCamGroupAsharpV4HandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
// TODO add algo specific methords, this is a sample
|
XCamReturn setAttrib(rk_aiq_sharp_attrib_v4_t *att);
|
XCamReturn getAttrib(rk_aiq_sharp_attrib_v4_t *att);
|
XCamReturn setStrength(rk_aiq_sharp_strength_v4_t *pStrength);
|
XCamReturn getStrength(rk_aiq_sharp_strength_v4_t *pStrength);
|
|
protected:
|
|
private:
|
|
rk_aiq_sharp_attrib_v4_t mCurAtt;
|
rk_aiq_sharp_attrib_v4_t mNewAtt;
|
rk_aiq_sharp_strength_v4_t mCurStrength;
|
rk_aiq_sharp_strength_v4_t mNewStrength;
|
mutable std::atomic<bool> updateStrength;
|
};
|
|
class RkAiqCamGroupAbayertnrV2HandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAbayertnrV2HandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
updateAtt = false;
|
updateStrength = false;
|
memset(&mCurStrength, 0x00, sizeof(mCurStrength));
|
mCurStrength.percent = 1.0;
|
memset(&mNewStrength, 0x00, sizeof(mNewStrength));
|
mNewStrength.percent = 1.0;
|
memset(&mCurAtt, 0x00, sizeof(mCurAtt));
|
memset(&mNewAtt, 0x00, sizeof(mNewAtt));
|
|
};
|
virtual ~RkAiqCamGroupAbayertnrV2HandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
// TODO add algo specific methords, this is a sample
|
XCamReturn setAttrib(rk_aiq_bayertnr_attrib_v2_t *att);
|
XCamReturn getAttrib(rk_aiq_bayertnr_attrib_v2_t *att);
|
XCamReturn setStrength(rk_aiq_bayertnr_strength_v2_t *pStrength);
|
XCamReturn getStrength(rk_aiq_bayertnr_strength_v2_t *pStrength);
|
|
protected:
|
|
private:
|
|
rk_aiq_bayertnr_attrib_v2_t mCurAtt;
|
rk_aiq_bayertnr_attrib_v2_t mNewAtt;
|
rk_aiq_bayertnr_strength_v2_t mCurStrength;
|
rk_aiq_bayertnr_strength_v2_t mNewStrength;
|
mutable std::atomic<bool> updateStrength;
|
};
|
|
// aldch
|
class RkAiqCamGroupAldchHandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAldchHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(rk_aiq_ldch_attrib_t));
|
memset(&mNewAtt, 0, sizeof(rk_aiq_ldch_attrib_t));
|
};
|
virtual ~RkAiqCamGroupAldchHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
// TODO add algo specific methords, this is a sample
|
XCamReturn setAttrib(rk_aiq_ldch_attrib_t att);
|
XCamReturn getAttrib(rk_aiq_ldch_attrib_t *att);
|
|
protected:
|
|
private:
|
// TODO
|
rk_aiq_ldch_attrib_t mCurAtt;
|
rk_aiq_ldch_attrib_t mNewAtt;
|
};
|
|
// adebayer
|
class RkAiqCamGroupAdebayerHandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAdebayerHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(adebayer_attrib_t));
|
memset(&mNewAtt, 0, sizeof(adebayer_attrib_t));
|
};
|
virtual ~RkAiqCamGroupAdebayerHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
// TODO add algo specific methords, this is a sample
|
XCamReturn setAttrib(adebayer_attrib_t att);
|
XCamReturn getAttrib(adebayer_attrib_t *att);
|
|
protected:
|
|
private:
|
// TODO
|
adebayer_attrib_t mCurAtt;
|
adebayer_attrib_t mNewAtt;
|
};
|
|
// lsc
|
class RkAiqCamGroupAlscHandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAlscHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(rk_aiq_lsc_attrib_t));
|
memset(&mNewAtt, 0, sizeof(rk_aiq_lsc_attrib_t));
|
};
|
virtual ~RkAiqCamGroupAlscHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
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:
|
|
private:
|
// TODO
|
rk_aiq_lsc_attrib_t mCurAtt;
|
rk_aiq_lsc_attrib_t mNewAtt;
|
};
|
|
// dpcc
|
class RkAiqCamGroupAdpccHandleInt:
|
public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAdpccHandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
memset(&mCurAtt, 0, sizeof(rk_aiq_dpcc_attrib_V20_t));
|
memset(&mNewAtt, 0, sizeof(rk_aiq_dpcc_attrib_V20_t));
|
};
|
virtual ~RkAiqCamGroupAdpccHandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
XCamReturn setAttrib(rk_aiq_dpcc_attrib_V20_t att);
|
XCamReturn getAttrib(rk_aiq_dpcc_attrib_V20_t* att);
|
|
protected:
|
|
private:
|
rk_aiq_dpcc_attrib_V20_t mCurAtt;
|
rk_aiq_dpcc_attrib_V20_t mNewAtt;
|
};
|
|
class RkAiqCamGroupAgainV2HandleInt:
|
virtual public RkAiqCamgroupHandle {
|
public:
|
explicit RkAiqCamGroupAgainV2HandleInt(RkAiqAlgoDesComm* des,
|
RkAiqCamGroupManager* camGroupMg)
|
: RkAiqCamgroupHandle(des, camGroupMg) {
|
updateAtt = false;
|
memset(&mCurAtt, 0x00, sizeof(mCurAtt));
|
memset(&mNewAtt, 0x00, sizeof(mNewAtt));
|
|
};
|
virtual ~RkAiqCamGroupAgainV2HandleInt() {
|
RkAiqCamgroupHandle::deInit();
|
};
|
virtual XCamReturn updateConfig(bool needSync);
|
XCamReturn setAttrib(rk_aiq_gain_attrib_v2_t *att);
|
XCamReturn getAttrib(rk_aiq_gain_attrib_v2_t *att);
|
protected:
|
|
private:
|
// TODO
|
rk_aiq_gain_attrib_v2_t mCurAtt;
|
rk_aiq_gain_attrib_v2_t mNewAtt;
|
|
};
|
|
|
};
|
|
#endif
|
