/*
|
* Copyright (c) 2019-2021 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_CORE_H_
|
#define _RK_AIQ_CORE_H_
|
|
#include "rk_aiq_types.h"
|
#include "rk_aiq_algo_types.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 "MessageBus.h"
|
#include "common/panorama_stitchingApp.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<VideoBuffer> RkAiqCoreVdBufMsg;
|
|
class RkAiqCore;
|
class MessageThread;
|
class RkAiqAnalyzerGroup;
|
class RkAiqAnalyzeGroupManager;
|
|
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;
|
bool is_multi_isp_mode;
|
uint16_t multi_isp_extended_pixel;
|
enum RK_PS_SrcOverlapPosition module_rotation;
|
};
|
|
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;
|
uint8_t algo_ver;
|
uint8_t module_hw_ver;
|
uint8_t handle_ver;
|
RkAiqGrpConditions_t grpConds;
|
};
|
|
#ifdef RKAIQ_ENABLE_CAMGROUP
|
class RkAiqCamGroupManager;
|
#endif
|
|
class RkAiqCore
|
: public rk_aiq_share_ptr_ops_t
|
{
|
friend class RkAiqCoreThread;
|
friend class RkAiqCoreEvtsThread;
|
friend class MessageThread;
|
friend class RkAiqAnalyzeGroup;
|
friend class RkAiqAnalyzeGroupManager;
|
|
#ifdef RKAIQ_ENABLE_CAMGROUP
|
friend class RkAiqCamGroupManager;
|
#endif
|
|
public:
|
RkAiqCore() = delete;
|
explicit RkAiqCore(int isp_hw_ver);
|
virtual ~RkAiqCore();
|
|
bool setAnalyzeResultCb(RkAiqAnalyzerCb* callback) {
|
mCb = callback;
|
return true;
|
}
|
|
#ifdef RKAIQ_ENABLE_CAMGROUP
|
void setCamGroupManager(RkAiqCamGroupManager* cam_group_manager) {
|
mCamGroupCoreManager = cam_group_manager;
|
if (mTranslator.ptr() && cam_group_manager)
|
mTranslator->setGroupMode(true);
|
}
|
#endif
|
// 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
|
virtual 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);
|
RkAiqAlgoContext* getEnabledAxlibCtx(const int algo_type);
|
RkAiqAlgoContext* getAxlibCtx(const int algo_type, const int lib_id);
|
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;
|
}
|
#ifdef RKAIQ_ENABLE_PARSER_V1
|
XCamReturn setCalib(const CamCalibDbContext_t* aiqCalib);
|
#endif
|
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);
|
|
void setMulCamConc(bool cc) { mAlogsComSharedParams.is_multi_sensor = cc; };
|
void setCamPhyId(int phyId) {
|
mAlogsComSharedParams.mCamPhyId = phyId;
|
mTranslator->setCamPhyId(phyId);
|
}
|
int getCamPhyId() { return mAlogsComSharedParams.mCamPhyId;}
|
|
XCamReturn set_pdaf_support(bool support);
|
bool get_pdaf_support();
|
|
public:
|
// following vars shared by all algo handlers
|
typedef struct RkAiqAlgosComShared_s {
|
#ifdef RKAIQ_ENABLE_PARSER_V1
|
const CamCalibDbContext_t* calib;
|
#endif
|
const CamCalibDbV2Context_t* calibv2;
|
rk_aiq_exposure_sensor_descriptor snsDes;
|
int64_t sof;
|
int working_mode;
|
uint16_t multi_isp_extended_pixels;
|
bool is_multi_isp_mode;
|
bool fill_light_on;
|
bool gray_mode;
|
bool init;
|
bool reConfig;
|
bool is_bw_sensor;
|
bool is_multi_sensor;
|
uint32_t hardware_version;
|
int iso;
|
AlgoCtxInstanceCfg 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;
|
int mCamPhyId;
|
|
void reset() {
|
xcam_mem_clear(ctxCfigs);
|
xcam_mem_clear(cpslCfg);
|
xcam_mem_clear(snsDes);
|
#ifdef RKAIQ_ENABLE_PARSER_V1
|
calib = NULL;
|
#endif
|
calibv2 = NULL;
|
sof = -1;
|
working_mode = 0;
|
is_multi_sensor = 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;
|
mCamPhyId = -1;
|
multi_isp_extended_pixels = 0;
|
is_multi_isp_mode = false;
|
}
|
} RkAiqAlgosComShared_t;
|
|
// following vars shared among itself by algo handlers
|
typedef struct RkAiqAlgosGroupShared_s {
|
int32_t groupId;
|
uint32_t frameId;
|
int64_t sof;
|
XCamVideoBuffer* ispStats;
|
RKAiqAecExpInfo_t preExp;
|
RKAiqAecExpInfo_t curExp;
|
RKAiqAecExpInfo_t nxtExp;
|
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;
|
XCamVideoBuffer* pdafStatsBuf;
|
RkAiqResComb res_comb;
|
void reset() {
|
frameId = -1;
|
sof = 0;
|
xcam_mem_clear(res_comb);
|
xcam_mem_clear(amdResParams);
|
xcam_mem_clear(preExp);
|
xcam_mem_clear(curExp);
|
xcam_mem_clear(nxtExp);
|
ispStats = nullptr;
|
sp = nullptr;
|
ispGain = nullptr;
|
kgGain = nullptr;
|
wrGain = nullptr;
|
tx = nullptr;
|
aecStatsBuf = nullptr;
|
awbStatsBuf = nullptr;
|
afStatsBuf = nullptr;
|
orbStats = nullptr;
|
nrImg = nullptr;
|
pdafStatsBuf = 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;
|
}
|
// TODO(Cody): Just AF use it, should it be public ?
|
SmartPtr<RkAiqHandle>* getCurAlgoTypeHandle(int algo_type);
|
virtual XCamReturn genCpslResult(RkAiqFullParams* params, RkAiqAlgoPreResAsd* asd_pre_rk);
|
|
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);
|
std::map<int, SmartPtr<RkAiqHandle>>* getAlgoTypeHandleMap(int algo_type);
|
void addDefaultAlgos(const struct RkAiqAlgoDesCommExt* algoDes);
|
virtual SmartPtr<RkAiqHandle> newAlgoHandle(RkAiqAlgoDesComm* algo, int hw_ver, int handle_ver);
|
virtual void copyIspStats(SmartPtr<RkAiqAecStatsProxy>& aecStat,
|
SmartPtr<RkAiqAwbStatsProxy>& awbStat,
|
SmartPtr<RkAiqAfStatsProxy>& afStat,
|
rk_aiq_isp_stats_t* to);
|
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;
|
bool mIsSingleThread;
|
// key1: algo type
|
// key2: algo id
|
// contains default handlers and custom handlers
|
std::map<int, map<int, SmartPtr<RkAiqHandle>>> mAlgoHandleMaps;
|
// key: algo type
|
// mCurAlgoHandleMaps and mCurIspAlgoHandleList only contain default handlers(id == 0),
|
// default handlers will be treated as root handler, and custom handlers as children.
|
// Custom handlers located in mAlgoHandleMaps and nexthdl of default handlers.
|
std::map<int, SmartPtr<RkAiqHandle>> mCurAlgoHandleMaps;
|
// ordered algo list
|
std::list<SmartPtr<RkAiqHandle>> mCurIspAlgoHandleList;
|
|
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<RkAiqIspDrcParamsPool> mAiqIspDrcParamsPool;
|
SmartPtr<RkAiqIspBlcParamsPoolV21> mAiqIspBlcV21ParamsPool;
|
SmartPtr<RkAiqIspBaynrParamsPoolV21> mAiqIspBaynrV21ParamsPool;
|
SmartPtr<RkAiqIspBa3dParamsPoolV21> mAiqIspBa3dV21ParamsPool;
|
SmartPtr<RkAiqIspYnrParamsPoolV21> mAiqIspYnrV21ParamsPool;
|
SmartPtr<RkAiqIspCnrParamsPoolV21> mAiqIspCnrV21ParamsPool;
|
SmartPtr<RkAiqIspSharpenParamsPoolV21> mAiqIspSharpenV21ParamsPool;
|
|
// V30
|
SmartPtr<RkAiqIspAwbParamsPoolV3x> mAiqIspAwbV3xParamsPool;
|
SmartPtr<RkAiqIspAfParamsPoolV3x> mAiqIspAfV3xParamsPool;
|
SmartPtr<RkAiqIspCacParamsPoolV3x> mAiqIspCacV3xParamsPool;
|
SmartPtr<RkAiqIspGainParamsPoolV3x> mAiqIspGainV3xParamsPool;
|
SmartPtr<RkAiqIspBaynrParamsPoolV3x> mAiqIspBaynrV3xParamsPool;
|
SmartPtr<RkAiqIspBa3dParamsPoolV3x> mAiqIspBa3dV3xParamsPool;
|
SmartPtr<RkAiqIspYnrParamsPoolV3x> mAiqIspYnrV3xParamsPool;
|
SmartPtr<RkAiqIspCnrParamsPoolV3x> mAiqIspCnrV3xParamsPool;
|
SmartPtr<RkAiqIspSharpenParamsPoolV3x> mAiqIspSharpenV3xParamsPool;
|
SmartPtr<RkAiqIspTnrParamsPoolV3x> mAiqIspTnrV3xParamsPool;
|
|
#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;
|
SmartPtr<RkAiqPdafStatsPool> mAiqPdafStatsPool;
|
|
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
|
virtual XCamReturn handle_message (const SmartPtr<XCamMessage> &msg);
|
|
// the group manager handle the messages from MessageBus
|
XCamReturn newAiqGroupAnayzer();
|
SmartPtr<RkAiqAnalyzeGroupManager> mRkAiqCoreGroupManager;
|
|
XCamReturn thumbnailsGroupAnalyze(rkaiq_image_source_t &thumbnailsSrc);
|
XCamReturn groupAnalyze(uint64_t grpId, const RkAiqAlgosGroupShared_t* shared);
|
|
virtual void newAiqParamsPool();
|
void newPdafStatsPool();
|
void delPdafStatsPool();
|
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,
|
const SmartPtr<RkAiqAecStatsProxy>& aecStat,
|
const SmartPtr<RkAiqAwbStatsProxy>& awbStat,
|
const SmartPtr<RkAiqAfStatsProxy>& afStat,
|
const SmartPtr<RkAiqAtmoStatsProxy>& tmoStat,
|
const SmartPtr<RkAiqAdehazeStatsProxy>& dehazeStat);
|
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, SmartPtr<RkAiqAtmoStatsProxy>& tmoStat);
|
XCamReturn handleAdehazeStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAdehazeStatsProxy>& dehazeStat);
|
XCamReturn handleOrbStats(const SmartPtr<VideoBuffer> &buffer);
|
XCamReturn handlePdafStats(const SmartPtr<VideoBuffer> &buffer);
|
inline uint64_t grpId2GrpMask(uint32_t grpId) {
|
return grpId == RK_AIQ_CORE_ANALYZE_ALL ? (uint64_t)grpId : (1ULL << grpId);
|
}
|
|
virtual void setReqAlgoResMask(int algoType, bool req);
|
|
SmartPtr<IRkAiqResourceTranslator> mTranslator;
|
uint32_t mLastAnalyzedId;
|
#ifdef RKAIQ_ENABLE_CAMGROUP
|
RkAiqCamGroupManager* mCamGroupCoreManager;
|
#endif
|
uint64_t mAllReqAlgoResMask;
|
|
private:
|
SmartPtr<ThumbnailsService> mThumbnailsService;
|
int mSpWidth;
|
int mSpHeight;
|
int mSpAlignedWidth;
|
int mSpAlignedHeight;
|
uint64_t mCustomEnAlgosMask;
|
bool mPdafSupport;
|
};
|
|
};
|
|
#endif //_RK_AIQ_CORE_H_
|
