/*
|
* rkisp_aiq_core.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_CORE_H_
|
#define _RK_AIQ_CORE_H_
|
|
#include "rk_aiq_types.h"
|
#include "rk_aiq_algo_types_int.h"
|
#include "RkAiqCalibDb.h"
|
#include "RkAiqCalibDbV2.h"
|
#include "RkAiqCalibDbV2Helper.h"
|
#include "RkAiqCalibDbTypes.h"
|
#include "RkAiqHandle.h"
|
#include "xcam_thread.h"
|
#include "smartptr.h"
|
#include "safe_list.h"
|
#include "xcam_log.h"
|
#include "video_buffer.h"
|
#include "rk_aiq_pool.h"
|
#include "ICamHw.h"
|
#include <memory>
|
#include "RkAiqResourceTranslator.h"
|
#include "RkAiqSharedDataManager.h"
|
#include "MessageBus.h"
|
|
using namespace XCam;
|
namespace RkCam {
|
|
#define RKAIQCORE_CHECK_RET(ret, format, ...) \
|
do { \
|
if (ret < 0) { \
|
LOGE_ANALYZER(format, ##__VA_ARGS__); \
|
return ret; \
|
} else if (ret == XCAM_RETURN_BYPASS) { \
|
LOGW_ANALYZER("bypass !", __FUNCTION__, __LINE__); \
|
return ret; \
|
} \
|
} while (0)
|
|
#define RKAIQCORE_CHECK_RET_NULL(ret, format, ...) \
|
do { \
|
if (ret < 0) { \
|
LOGE_ANALYZER(format, ##__VA_ARGS__); \
|
return NULL; \
|
} else if (ret == XCAM_RETURN_BYPASS) { \
|
LOGW_ANALYZER("bypass !", __FUNCTION__, __LINE__); \
|
return NULL; \
|
} \
|
} while (0)
|
|
#define RKAIQCORE_CHECK_BYPASS(ret, format, ...) \
|
do { \
|
if (ret < 0) { \
|
LOGE_ANALYZER(format, ##__VA_ARGS__); \
|
return ret; \
|
} else if (ret == XCAM_RETURN_BYPASS) { \
|
LOGW_ANALYZER("bypass !", __FUNCTION__, __LINE__); \
|
ret = XCAM_RETURN_NO_ERROR; \
|
} \
|
} while (0)
|
|
#define grp_array_size(x) (sizeof(x)/sizeof(x[0]))
|
#define grp_conds_array_info(x) \
|
x, \
|
grp_array_size(x)
|
|
template <typename StandardMsg>
|
class RkAiqCoreMsg
|
: public XCamMessage
|
{
|
public:
|
RkAiqCoreMsg(XCamMessageType msg_id, uint32_t id, const SmartPtr<StandardMsg> &message)
|
: XCamMessage(msg_id, id)
|
, msg(message)
|
{};
|
virtual ~RkAiqCoreMsg() {};
|
|
SmartPtr<StandardMsg> msg;
|
|
private:
|
XCAM_DEAD_COPY (RkAiqCoreMsg);
|
};
|
typedef RkAiqCoreMsg<RkAiqIspStatsIntProxy> RkAiqCoreIspStatsMsg;
|
typedef RkAiqCoreMsg<RkAiqSofInfoWrapperProxy> RkAiqCoreExpMsg;
|
typedef RkAiqCoreMsg<VideoBuffer> RkAiqCoreVdBufMsg;
|
|
typedef struct grp0AnalyzerInParams_s {
|
uint32_t id;
|
SmartPtr<RkAiqCoreExpMsg> sofInfoMsg;
|
XCamVideoBuffer* aecStatsBuf;
|
XCamVideoBuffer* awbStatsBuf;
|
XCamVideoBuffer* afStatsBuf;
|
XCamVideoBuffer* aePreRes;
|
XCamVideoBuffer* aeProcRes;
|
} grp0AnalyzerInParams_t;
|
|
typedef struct grp1AnalyzerInParams_s {
|
uint32_t id;
|
SmartPtr<RkAiqCoreExpMsg> sofInfoMsg;
|
XCamVideoBuffer* aecStatsBuf;
|
XCamVideoBuffer* awbStatsBuf;
|
XCamVideoBuffer* afStatsBuf;
|
XCamVideoBuffer* aePreRes;
|
XCamVideoBuffer* awbProcRes;
|
} grp1AnalyzerInParams_t;
|
|
typedef struct afAnalyzerInParams_s {
|
uint32_t id;
|
SmartPtr<RkAiqCoreExpMsg> expInfo;
|
XCamVideoBuffer* aecStatsBuf;
|
XCamVideoBuffer* afStatsBuf;
|
XCamVideoBuffer* aePreRes;
|
XCamVideoBuffer* aeProcRes;
|
} afAnalyzerInParams_t;
|
|
class RkAiqCore;
|
class MessageThread;
|
class RkAiqAnalyzerGroup;
|
class RkAiqAnalyzeGroupManager;
|
#if 0
|
class RkAiqIspStats {
|
public:
|
explicit RkAiqIspStats() {
|
xcam_mem_clear(aec_stats);
|
xcam_mem_clear(awb_stats);
|
xcam_mem_clear(awb_stats_v201);
|
xcam_mem_clear(awb_cfg_effect_v200);
|
xcam_mem_clear(awb_cfg_effect_v201);
|
xcam_mem_clear(af_stats);
|
xcam_mem_clear(orb_stats);
|
orb_stats.img_buf_index = -1;
|
orb_stats.frame_id = -1;
|
aec_stats_valid = false;
|
awb_stats_valid = false;
|
awb_cfg_effect_valid = false;
|
af_stats_valid = false;
|
frame_id = -1;
|
};
|
~RkAiqIspStats() {};
|
rk_aiq_isp_aec_stats_t aec_stats;
|
bool aec_stats_valid;
|
rk_aiq_awb_stat_res_v200_t awb_stats;
|
rk_aiq_awb_stat_cfg_v200_t awb_cfg_effect_v200;
|
rk_aiq_awb_stat_res_v201_t awb_stats_v201;
|
rk_aiq_awb_stat_cfg_v201_t awb_cfg_effect_v201;
|
|
bool awb_stats_valid;
|
bool awb_cfg_effect_valid;
|
rk_aiq_isp_af_stats_t af_stats;
|
bool af_stats_valid;
|
rk_aiq_isp_orb_stats_t orb_stats;
|
bool orb_stats_valid;
|
rkisp_atmo_stats_t atmo_stats;
|
bool atmo_stats_valid;
|
rkisp_adehaze_stats_t adehaze_stats;
|
bool adehaze_stats_valid;
|
uint32_t frame_id;
|
rk_aiq_amd_algo_stat_t amd_stats;
|
private:
|
XCAM_DEAD_COPY (RkAiqIspStats);
|
};
|
#endif
|
|
class RkAiqAnalyzerCb {
|
public:
|
explicit RkAiqAnalyzerCb() {};
|
virtual ~RkAiqAnalyzerCb() {};
|
virtual void rkAiqCalcDone(SmartPtr<RkAiqFullParamsProxy> &results) = 0;
|
virtual void rkAiqCalcFailed(const char* msg) = 0;
|
private:
|
XCAM_DEAD_COPY (RkAiqAnalyzerCb);
|
};
|
|
class RkAiqCoreThread
|
: public Thread {
|
public:
|
RkAiqCoreThread(RkAiqCore* rkAiqCore)
|
: Thread("RkAiqCoreThread")
|
, mRkAiqCore(rkAiqCore) {};
|
~RkAiqCoreThread() {
|
mStatsQueue.clear ();
|
};
|
|
void triger_stop() {
|
mStatsQueue.pause_pop ();
|
};
|
|
void triger_start() {
|
mStatsQueue.clear ();
|
mStatsQueue.resume_pop ();
|
};
|
|
bool push_stats (const SmartPtr<VideoBuffer> &buffer) {
|
mStatsQueue.push (buffer);
|
return true;
|
};
|
|
protected:
|
//virtual bool started ();
|
virtual void stopped () {
|
mStatsQueue.clear ();
|
};
|
virtual bool loop ();
|
private:
|
RkAiqCore* mRkAiqCore;
|
SafeList<VideoBuffer> mStatsQueue;
|
};
|
|
class RkAiqCoreEvtsThread
|
: public Thread {
|
public:
|
RkAiqCoreEvtsThread(RkAiqCore* rkAiqCore)
|
: Thread("RkAiqCoreEvtsThread")
|
, mRkAiqCore(rkAiqCore) {};
|
~RkAiqCoreEvtsThread() {
|
mEvtsQueue.clear ();
|
};
|
|
void triger_stop() {
|
mEvtsQueue.pause_pop ();
|
};
|
|
void triger_start() {
|
mEvtsQueue.clear ();
|
mEvtsQueue.resume_pop ();
|
};
|
|
bool push_evts (const SmartPtr<ispHwEvt_t> &buffer) {
|
mEvtsQueue.push (buffer);
|
return true;
|
};
|
|
protected:
|
//virtual bool started ();
|
virtual void stopped () {
|
mEvtsQueue.clear ();
|
};
|
virtual bool loop ();
|
private:
|
RkAiqCore* mRkAiqCore;
|
SafeList<ispHwEvt_t> mEvtsQueue;
|
};
|
|
struct RkAiqHwInfo {
|
bool fl_supported; // led flash
|
bool fl_strth_adj; // led streng_adjust
|
bool irc_supported; // ir flash & ir cutter
|
bool fl_ir_strth_adj; // ir streng_adjust
|
bool lens_supported;
|
};
|
|
typedef struct RkAiqGrpCondition_s {
|
enum XCamMessageType cond;
|
int8_t delay;
|
} RkAiqGrpCondition_t;
|
|
typedef struct RkAiqGrpConditions_s {
|
RkAiqGrpCondition_t* conds;
|
u32 size;
|
} RkAiqGrpConditions_t;
|
|
struct RkAiqAlgoDesCommExt {
|
RkAiqAlgoDesComm* des;
|
enum rk_aiq_core_analyze_type_e group;
|
int algo_ver;
|
int module_hw_ver;
|
RkAiqGrpConditions_t grpConds;
|
};
|
|
class RkAiqCore
|
: public rk_aiq_share_ptr_ops_t
|
{
|
friend class RkAiqCoreThread;
|
friend class RkAiqCoreEvtsThread;
|
friend class MessageThread;
|
friend class RkAiqAnalyzeGroup;
|
friend class RkAiqAnalyzeGroupManager;
|
public:
|
RkAiqCore();
|
virtual ~RkAiqCore();
|
|
bool setAnalyzeResultCb(RkAiqAnalyzerCb* callback) {
|
mCb = callback;
|
return true;
|
}
|
// called only once
|
XCamReturn init(const char* sns_ent_name, const CamCalibDbContext_t* aiqCalib,
|
const CamCalibDbV2Context_t* aiqCalibv2 = nullptr);
|
// called only once
|
XCamReturn deInit();
|
// start analyze thread
|
XCamReturn start();
|
// stop analyze thread
|
XCamReturn stop();
|
// called before start(), get initial settings
|
XCamReturn prepare(const rk_aiq_exposure_sensor_descriptor* sensor_des,
|
int mode);
|
// should called befor prepare
|
void notifyIspStreamMode(rk_isp_stream_mode_t mode) {
|
if (mode == RK_ISP_STREAM_MODE_ONLNIE) {
|
mIspOnline = true;
|
} else if (mode == RK_ISP_STREAM_MODE_OFFLNIE) {
|
mIspOnline = false;
|
} else {
|
mIspOnline = false;
|
}
|
}
|
// could be called after prepare() or start()
|
// if called between prepare() start(), can get
|
// initial settings
|
SmartPtr<RkAiqFullParamsProxy>& getAiqFullParams() {
|
return mAiqCurParams;
|
};
|
XCamReturn pushStats(SmartPtr<VideoBuffer> &buffer);
|
XCamReturn pushEvts(SmartPtr<ispHwEvt_t> &evts);
|
XCamReturn addAlgo(RkAiqAlgoDesComm& algo);
|
XCamReturn enableAlgo(int algoType, int id, bool enable);
|
XCamReturn rmAlgo(int algoType, int id);
|
bool getAxlibStatus(int algoType, int id);
|
const RkAiqAlgoContext* getEnabledAxlibCtx(const int algo_type);
|
const RkAiqHandle* getAiqAlgoHandle(const int algo_type);
|
XCamReturn get3AStatsFromCachedList(rk_aiq_isp_stats_t &stats);
|
XCamReturn get3AStatsFromCachedList(rk_aiq_isp_stats_t **stats, int timeout_ms);
|
void release3AStatsRef(rk_aiq_isp_stats_t *stats);
|
XCamReturn setCpsLtCfg(rk_aiq_cpsl_cfg_t &cfg);
|
XCamReturn getCpsLtInfo(rk_aiq_cpsl_info_t &info);
|
XCamReturn queryCpsLtCap(rk_aiq_cpsl_cap_t &cap);
|
XCamReturn setHwInfos(struct RkAiqHwInfo &hw_info);
|
XCamReturn setGrayMode(rk_aiq_gray_mode_t mode);
|
rk_aiq_gray_mode_t getGrayMode();
|
void setSensorFlip(bool mirror, bool flip);
|
void setResrcPath(const char* rp) {
|
if (mAlogsComSharedParams.resourcePath) {
|
xcam_free((void*)(mAlogsComSharedParams.resourcePath));
|
mAlogsComSharedParams.resourcePath = NULL;
|
}
|
if (rp)
|
mAlogsComSharedParams.resourcePath = strdup(rp);
|
};
|
bool isRunningState() {
|
return mState == RK_AIQ_CORE_STATE_RUNNING;
|
}
|
void setShareMemOps(isp_drv_share_mem_ops_t *mem_ops) {
|
mShareMemOps = mem_ops;
|
}
|
XCamReturn setCalib(const CamCalibDbContext_t* aiqCalib);
|
XCamReturn setCalib(const CamCalibDbV2Context_t* aiqCalib);
|
XCamReturn events_analyze(const SmartPtr<ispHwEvt_t> &evts);
|
XCamReturn calibTuning(const CamCalibDbV2Context_t* aiqCalib,
|
ModuleNameList& change_list);
|
XCamReturn setMemsSensorIntf(const rk_aiq_mems_sensor_intf_t* intf);
|
const rk_aiq_mems_sensor_intf_t* getMemsSensorIntf();
|
XCamReturn set_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h);
|
public:
|
// following vars shared by all algo handlers
|
typedef struct RkAiqAlgosComShared_s {
|
const CamCalibDbContext_t* calib;
|
const CamCalibDbV2Context_t* calibv2;
|
rk_aiq_exposure_sensor_descriptor snsDes;
|
int64_t sof;
|
int working_mode;
|
bool fill_light_on;
|
bool gray_mode;
|
bool init;
|
bool reConfig;
|
bool is_bw_sensor;
|
uint32_t hardware_version;
|
int iso;
|
AlgoCtxInstanceCfgInt ctxCfigs[RK_AIQ_ALGO_TYPE_MAX];
|
rk_aiq_cpsl_cfg_t cpslCfg;
|
int conf_type;
|
const char* resourcePath;
|
bool sns_mirror;
|
bool sns_flip;
|
int spWidth;
|
int spHeight;
|
int spAlignedWidth;
|
int spAlignedHeight;
|
void reset() {
|
xcam_mem_clear(ctxCfigs);
|
xcam_mem_clear(cpslCfg);
|
xcam_mem_clear(snsDes);
|
calib = NULL;
|
calibv2 = NULL;
|
sof = -1;
|
working_mode = 0;
|
init = false;
|
reConfig = false;
|
hardware_version = 0;
|
iso = 0;
|
fill_light_on = false;
|
gray_mode = false;
|
is_bw_sensor = false;
|
resourcePath = NULL;
|
sns_mirror = false;
|
sns_flip = false;
|
conf_type = RK_AIQ_ALGO_CONFTYPE_INIT;
|
}
|
} RkAiqAlgosComShared_t;
|
|
// following vars shared among itself by algo handlers
|
typedef struct RkAiqAlgosGroupShared_s {
|
int32_t groupId;
|
uint32_t frameId;
|
int64_t sof;
|
RkAiqIspStats* ispStats;
|
RKAiqAecExpInfo_t preExp;
|
RKAiqAecExpInfo_t curExp;
|
rk_aiq_amd_params_t amdResParams;
|
XCamVideoBuffer* aecStatsBuf;
|
XCamVideoBuffer* awbStatsBuf;
|
XCamVideoBuffer* afStatsBuf;
|
XCamVideoBuffer* sp;
|
XCamVideoBuffer* ispGain;
|
XCamVideoBuffer* kgGain;
|
XCamVideoBuffer* wrGain;
|
XCamVideoBuffer* tx;
|
XCamVideoBuffer* orbStats;
|
XCamVideoBuffer* nrImg;
|
RkAiqResComb res_comb;
|
RkAiqPreResComb preResComb;
|
RkAiqProcResComb procResComb;
|
RkAiqPostResComb postResComb;
|
void reset() {
|
frameId = -1;
|
sof = 0;
|
xcam_mem_clear(res_comb);
|
xcam_mem_clear(preResComb);
|
xcam_mem_clear(procResComb);
|
xcam_mem_clear(postResComb);
|
xcam_mem_clear(amdResParams);
|
sp = nullptr;
|
ispGain = nullptr;
|
kgGain = nullptr;
|
wrGain = nullptr;
|
tx = nullptr;
|
aecStatsBuf = nullptr;
|
awbStatsBuf = nullptr;
|
afStatsBuf = nullptr;
|
orbStats = nullptr;
|
}
|
} RkAiqAlgosGroupShared_t;
|
RkAiqAlgosComShared_t mAlogsComSharedParams;
|
// key: group type
|
std::map<int32_t, RkAiqAlgosGroupShared_t *> mAlogsGroupSharedParamsMap;
|
|
// key: algo type
|
std::map<int32_t, uint64_t> mAlgoTypeToGrpMaskMap;
|
std::list<uint32_t> mAlogsGroupList;
|
// std::map<int32_t, uint64_t> mGrpType2GrpMaskMap;
|
|
isp_drv_share_mem_ops_t *mShareMemOps;
|
|
void post_message (SmartPtr<XCamMessage> &msg);
|
int32_t getGroupId(RkAiqAlgoType_t type);
|
XCamReturn getGroupSharedParams(int32_t groupId, RkAiqAlgosGroupShared_t* &shared);
|
uint64_t getCustomEnAlgosMask() {
|
return mCustomEnAlgosMask;
|
}
|
|
protected:
|
// in analyzer thread
|
XCamReturn analyze(const SmartPtr<VideoBuffer> &buffer);
|
SmartPtr<RkAiqFullParamsProxy> analyzeInternal(enum rk_aiq_core_analyze_type_e type);
|
XCamReturn preProcess(enum rk_aiq_core_analyze_type_e type);
|
XCamReturn processing(enum rk_aiq_core_analyze_type_e type);
|
XCamReturn postProcess(enum rk_aiq_core_analyze_type_e type);
|
SmartPtr<RkAiqHandle>* getCurAlgoTypeHandle(int algo_type);
|
std::map<int, SmartPtr<RkAiqHandle>>* getAlgoTypeHandleMap(int algo_type);
|
void addDefaultAlgos(const struct RkAiqAlgoDesCommExt* algoDes);
|
virtual SmartPtr<RkAiqHandle> newAlgoHandle(RkAiqAlgoDesComm* algo, bool generic, int hw_ver);
|
virtual void copyIspStats(SmartPtr<RkAiqAecStatsProxy>& aecStat,
|
SmartPtr<RkAiqAwbStatsProxy>& awbStat,
|
SmartPtr<RkAiqAfStatsProxy>& afStat,
|
rk_aiq_isp_stats_t* to);
|
|
virtual XCamReturn genIspAeResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAwbResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAfResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAmergeResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAtmoResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAnrResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAdhazResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAsdResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAcpResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAieResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAsharpResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspA3dlutResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAblcResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAccmResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAcgcResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAdebayerResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAdpccResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAfecResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAgammaResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAdegammaResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAgicResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAldchResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAlscResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAorbResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAr2yResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAwdrResult(RkAiqFullParams* params);
|
virtual XCamReturn genCpslResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspArawnrResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAmfnrResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAynrResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAcnrResult(RkAiqFullParams* params);
|
// virtual XCamReturn genIspAdrcResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAeisResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAmdResult(RkAiqFullParams* params);
|
virtual XCamReturn genIspAgainResult(RkAiqFullParams* params);
|
virtual void setResultExpectedEffId(uint32_t& eff_id, enum RkAiqAlgoType_e type);
|
void cacheIspStatsToList(SmartPtr<RkAiqAecStatsProxy>& aecStat,
|
SmartPtr<RkAiqAwbStatsProxy>& awbStat,
|
SmartPtr<RkAiqAfStatsProxy>& afStat);
|
void initCpsl();
|
|
protected:
|
enum rk_aiq_core_state_e {
|
RK_AIQ_CORE_STATE_INVALID,
|
RK_AIQ_CORE_STATE_INITED,
|
RK_AIQ_CORE_STATE_PREPARED,
|
RK_AIQ_CORE_STATE_STARTED,
|
RK_AIQ_CORE_STATE_RUNNING,
|
RK_AIQ_CORE_STATE_STOPED,
|
};
|
SmartPtr<RkAiqCoreThread> mRkAiqCoreTh;
|
SmartPtr<RkAiqCoreThread> mRkAiqCorePpTh;
|
SmartPtr<RkAiqCoreEvtsThread> mRkAiqCoreEvtsTh;
|
int mState;
|
RkAiqAnalyzerCb* mCb;
|
bool mHasPp;
|
bool mIspOnline;
|
// key1: algo type
|
// key2: algo id
|
std::map<int, map<int, SmartPtr<RkAiqHandle>>> mAlgoHandleMaps;
|
// key: algo type
|
std::map<int, SmartPtr<RkAiqHandle>> mCurAlgoHandleMaps;
|
// ordered algo list
|
std::list<SmartPtr<RkAiqHandle>> mCurIspAlgoHandleList;
|
std::list<SmartPtr<RkAiqHandle>> mCurIsppAlgoHandleList;
|
|
SmartPtr<RkAiqFullParamsPool> mAiqParamsPool;
|
SmartPtr<RkAiqFullParamsProxy> mAiqCurParams;
|
SmartPtr<RkAiqExpParamsPool> mAiqExpParamsPool;
|
SmartPtr<RkAiqIrisParamsPool> mAiqIrisParamsPool;
|
SmartPtr<RkAiqFocusParamsPool> mAiqFocusParamsPool;
|
SmartPtr<RkAiqCpslParamsPool> mAiqCpslParamsPool;
|
#if 1
|
SmartPtr<RkAiqIspAecParamsPool> mAiqIspAecParamsPool;
|
SmartPtr<RkAiqIspHistParamsPool> mAiqIspHistParamsPool;
|
SmartPtr<RkAiqIspAwbParamsPool> mAiqIspAwbParamsPool;
|
SmartPtr<RkAiqIspAwbGainParamsPool> mAiqIspAwbGainParamsPool;
|
SmartPtr<RkAiqIspAfParamsPool> mAiqIspAfParamsPool;
|
SmartPtr<RkAiqIspDpccParamsPool> mAiqIspDpccParamsPool;
|
// SmartPtr<RkAiqIspHdrParamsPool> mAiqIspHdrParamsPool;
|
SmartPtr<RkAiqIspMergeParamsPool> mAiqIspMergeParamsPool;
|
SmartPtr<RkAiqIspTmoParamsPool> mAiqIspTmoParamsPool;
|
SmartPtr<RkAiqIspCcmParamsPool> mAiqIspCcmParamsPool;
|
SmartPtr<RkAiqIspLscParamsPool> mAiqIspLscParamsPool;
|
SmartPtr<RkAiqIspBlcParamsPool> mAiqIspBlcParamsPool;
|
SmartPtr<RkAiqIspRawnrParamsPool> mAiqIspRawnrParamsPool;
|
SmartPtr<RkAiqIspGicParamsPool> mAiqIspGicParamsPool;
|
SmartPtr<RkAiqIspDebayerParamsPool> mAiqIspDebayerParamsPool;
|
SmartPtr<RkAiqIspLdchParamsPool> mAiqIspLdchParamsPool;
|
SmartPtr<RkAiqIspLut3dParamsPool> mAiqIspLut3dParamsPool;
|
SmartPtr<RkAiqIspDehazeParamsPool> mAiqIspDehazeParamsPool;
|
SmartPtr<RkAiqIspAgammaParamsPool> mAiqIspAgammaParamsPool;
|
SmartPtr<RkAiqIspAdegammaParamsPool> mAiqIspAdegammaParamsPool;
|
SmartPtr<RkAiqIspWdrParamsPool> mAiqIspWdrParamsPool;
|
SmartPtr<RkAiqIspCsmParamsPool> mAiqIspCsmParamsPool;
|
SmartPtr<RkAiqIspCgcParamsPool> mAiqIspCgcParamsPool;
|
SmartPtr<RkAiqIspConv422ParamsPool> mAiqIspConv422ParamsPool;
|
SmartPtr<RkAiqIspYuvconvParamsPool> mAiqIspYuvconvParamsPool;
|
SmartPtr<RkAiqIspGainParamsPool> mAiqIspGainParamsPool;
|
SmartPtr<RkAiqIspCpParamsPool> mAiqIspCpParamsPool;
|
SmartPtr<RkAiqIspIeParamsPool> mAiqIspIeParamsPool;
|
SmartPtr<RkAiqIspMotionParamsPool> mAiqIspMotionParamsPool;
|
SmartPtr<RkAiqIspMdParamsPool> mAiqIspMdParamsPool;
|
|
SmartPtr<RkAiqIspTnrParamsPool> mAiqIspTnrParamsPool;
|
SmartPtr<RkAiqIspYnrParamsPool> mAiqIspYnrParamsPool;
|
SmartPtr<RkAiqIspUvnrParamsPool> mAiqIspUvnrParamsPool;
|
SmartPtr<RkAiqIspSharpenParamsPool> mAiqIspSharpenParamsPool;
|
SmartPtr<RkAiqIspEdgefltParamsPool> mAiqIspEdgefltParamsPool;
|
SmartPtr<RkAiqIspFecParamsPool> mAiqIspFecParamsPool;
|
SmartPtr<RkAiqIspOrbParamsPool> mAiqIspOrbParamsPool;
|
|
// TODO: change full params to list
|
// V21 differential modules
|
SmartPtr<RkAiqIspAwbParamsPoolV21> mAiqIspAwbV21ParamsPool;
|
SmartPtr<RkAiqIspDrcParamsPoolV21> mAiqIspDrcV21ParamsPool;
|
SmartPtr<RkAiqIspBlcParamsPoolV21> mAiqIspBlcV21ParamsPool;
|
SmartPtr<RkAiqIspGicParamsPoolV21> mAiqIspGicV21ParamsPool;
|
SmartPtr<RkAiqIspDehazeParamsPoolV21> mAiqIspDehazeV21ParamsPool;
|
SmartPtr<RkAiqIspBaynrParamsPoolV21> mAiqIspBaynrV21ParamsPool;
|
SmartPtr<RkAiqIspBa3dParamsPoolV21> mAiqIspBa3dV21ParamsPool;
|
SmartPtr<RkAiqIspYnrParamsPoolV21> mAiqIspYnrV21ParamsPool;
|
SmartPtr<RkAiqIspCnrParamsPoolV21> mAiqIspCnrV21ParamsPool;
|
SmartPtr<RkAiqIspSharpenParamsPoolV21> mAiqIspSharpenV21ParamsPool;
|
#endif
|
static uint16_t DEFAULT_POOL_SIZE;
|
XCam::Cond mIspStatsCond;
|
Mutex ispStatsListMutex;
|
struct RkAiqHwInfo mHwInfo;
|
rk_aiq_cpsl_cap_t mCpslCap;
|
bool mCurCpslOn;
|
float mStrthLed;
|
float mStrthIr;
|
rk_aiq_gray_mode_t mGrayMode;
|
bool firstStatsReceived;
|
typedef SharedItemPool<rk_aiq_isp_stats_wrapper_t> RkAiqStatsPool;
|
typedef SharedItemProxy<rk_aiq_isp_stats_wrapper_t> RkAiqStatsProxy;
|
SmartPtr<RkAiqStatsPool> mAiqStatsPool;
|
std::list<SmartPtr<RkAiqStatsProxy>> mAiqStatsCachedList;
|
std::map<rk_aiq_isp_stats_t*, SmartPtr<RkAiqStatsProxy>> mAiqStatsOutMap;
|
|
/* isp/ispp resource pool */
|
SmartPtr<RkAiqSofInfoWrapperPool> mAiqSofInfoWrapperPool;
|
SmartPtr<RkAiqIspStatsIntPool> mAiqIspStatsIntPool;
|
SmartPtr<RkAiqAecStatsPool> mAiqAecStatsPool;
|
SmartPtr<RkAiqAwbStatsPool> mAiqAwbStatsPool;
|
SmartPtr<RkAiqAtmoStatsPool> mAiqAtmoStatsPool;
|
SmartPtr<RkAiqAdehazeStatsPool> mAiqAdehazeStatsPool;
|
SmartPtr<RkAiqAfStatsPool> mAiqAfStatsPool;
|
SmartPtr<RkAiqOrbStatsPool> mAiqOrbStatsIntPool;
|
|
const struct RkAiqAlgoDesCommExt* mAlgosDesArray;
|
Mutex mApiMutex;
|
XCam::Cond mApiMutexCond;
|
bool mSafeEnableAlgo;
|
int mIspHwVer;
|
const rk_aiq_mems_sensor_intf_t *mMemsSensorIntf;
|
|
// messageBus: receive and distribute all kinds of messagess
|
SmartPtr<MessageThread> mRkAiqCoreMsgTh;
|
virtual XCamReturn handle_message (const SmartPtr<XCamMessage> &msg);
|
|
// the group manager handle the messages from MessageBus
|
XCamReturn newAiqGroupAnayzer();
|
SmartPtr<RkAiqAnalyzeGroupManager> mRkAiqCoreGroupManager;
|
|
XCamReturn measGroupAnalyze(uint32_t id, const SmartPtr<RkAiqCoreIspStatsMsg> &msg,
|
XCamVideoBuffer* aePreRes);
|
XCamReturn otherGroupAnalye(uint32_t id, const SmartPtr<RkAiqCoreExpMsg> &msg);
|
XCamReturn amdGroupAnalyze(uint32_t id, const SmartPtr<RkAiqCoreExpMsg> &expMsg,
|
XCamVideoBuffer* sp,
|
XCamVideoBuffer* ispGain);
|
XCamReturn thumbnailsGroupAnalyze(rkaiq_image_source_t &thumbnailsSrc);
|
XCamReturn lscGroupAnalyze(uint32_t id, const SmartPtr<RkAiqCoreExpMsg> &expMsg,
|
XCamVideoBuffer* awbProcRes, XCamVideoBuffer* tx);
|
XCamReturn aeGroupAnalyze(uint32_t id, XCamVideoBuffer* aecStatsBuf);
|
XCamReturn awbGroupAnalyze(int32_t id,
|
XCamVideoBuffer* aeProcRes,
|
XCamVideoBuffer* awbStatsBuf);
|
XCamReturn mfnrGroupAnalyze(uint32_t id, const SmartPtr<RkAiqCoreExpMsg> &expMsg,
|
XCamVideoBuffer* ispGain,
|
XCamVideoBuffer* kgGain,
|
rk_aiq_amd_params_t &amdParams);
|
XCamReturn ynrGroupAnalyze(uint32_t id, const SmartPtr<RkAiqCoreExpMsg> &expMsg,
|
XCamVideoBuffer* ispGain,
|
XCamVideoBuffer* wrGain,
|
rk_aiq_amd_params_t &amdParams);
|
XCamReturn grp0Analyze(grp0AnalyzerInParams_t &inParams);
|
XCamReturn grp1Analyze(grp1AnalyzerInParams_t &inParams);
|
XCamReturn afAnalyze(afAnalyzerInParams_t &inParams);
|
XCamReturn eisGroupAnalyze(uint32_t id, const SmartPtr<RkAiqCoreExpMsg>& expMsg,
|
XCamVideoBuffer* orbStats, XCamVideoBuffer* nrImg);
|
XCamReturn orbGroupAnalyze(uint32_t id, XCamVideoBuffer* orbStats);
|
|
virtual void newAiqParamsPool();
|
virtual XCamReturn getAiqParamsBuffer(RkAiqFullParams* aiqParams, enum rk_aiq_core_analyze_type_e type);
|
virtual XCamReturn genIspParamsResult(RkAiqFullParams *aiqParams, enum rk_aiq_core_analyze_type_e type);
|
//void getThumbCfgForStreams();
|
//void setThumbCfgFromStreams();
|
void onThumbnailsResult(const rkaiq_thumbnails_t& thumbnail);
|
XCamReturn handleIspStats(const SmartPtr<VideoBuffer> &buffer);
|
XCamReturn handleAecStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAecStatsProxy>& aecStat);
|
XCamReturn handleAwbStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAwbStatsProxy>& awbStat);
|
XCamReturn handleAfStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAfStatsProxy>& afStat);
|
XCamReturn handleAtmoStats(const SmartPtr<VideoBuffer> &buffer);
|
XCamReturn handleAdehazeStats(const SmartPtr<VideoBuffer> &buffer);
|
XCamReturn handleOrbStats(const SmartPtr<VideoBuffer> &buffer);
|
inline uint64_t grpId2GrpMask(uint32_t grpId) {
|
return grpId == RK_AIQ_CORE_ANALYZE_ALL ? grpId : 1 << grpId;
|
}
|
|
|
SmartPtr<IRkAiqResourceTranslator> mTranslator;
|
uint32_t mLastAnalyzedId;
|
|
private:
|
SmartPtr<ThumbnailsService> mThumbnailsService;
|
int mSpWidth;
|
int mSpHeight;
|
int mSpAlignedWidth;
|
int mSpAlignedHeight;
|
uint64_t mCustomEnAlgosMask;
|
};
|
|
};
|
|
#endif //_RK_AIQ_CORE_H_
|
