/*
|
* 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_HANDLE_H_
|
#define _RK_AIQ_HANDLE_H_
|
|
#include <map>
|
|
#include "rk_aiq_algo_types.h"
|
#include "rk_aiq_types.h"
|
#include "xcam_mutex.h"
|
#include "rk_aiq_pool.h"
|
|
namespace RkCam {
|
|
/*
|
--------------------------------
|
| :RkAiqHandle |
|
--------------------------------
|
| rk_aiq_xxx_attrib_t mCurAtt; |
|
| rk_aiq_xxx_attrib_t mNewAtt; |
|
| Mutex mCfgMutex; |
|
| bool updateAtt; |
|
--------------------------------
|
| updateConfig() |
|
--------------------------------
|
*/
|
|
class RkAiqCore;
|
struct RkAiqAlgosGroupShared_s;
|
|
class RkAiqHandle {
|
public:
|
explicit RkAiqHandle(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore);
|
virtual ~RkAiqHandle();
|
void setEnable(bool enable) { mEnable = enable; };
|
void setReConfig(bool reconfig) { mReConfig = reconfig; };
|
bool getEnable() { return mEnable; };
|
virtual XCamReturn prepare();
|
virtual XCamReturn preProcess();
|
virtual XCamReturn processing();
|
virtual XCamReturn postProcess();
|
virtual XCamReturn genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) { return XCAM_RETURN_NO_ERROR; };
|
RkAiqAlgoContext* getAlgoCtx() { return mAlgoCtx; }
|
const int getAlgoId() const { return mDes->id; }
|
const int getAlgoType() const { return mDes->type; }
|
void setGroupId(int32_t gId) {
|
mGroupId = gId;
|
}
|
int32_t getGroupId() {
|
return mGroupId;
|
}
|
|
void setNextHdl(RkAiqHandle* next) {
|
mNextHdl = next;
|
}
|
|
void setParentHdl(RkAiqHandle* parent) {
|
mParentHdl = parent;
|
}
|
|
RkAiqHandle* getNextHdl() {
|
return mNextHdl;
|
}
|
|
RkAiqHandle* getParent() {
|
return mParentHdl;
|
}
|
|
// rk algo running with custom algo concunrrently
|
void setMulRun(bool isMulRun) {
|
mIsMulRun = isMulRun;
|
if (isMulRun && mDes->id == 0)
|
mPostShared = false;
|
else
|
mPostShared = true;
|
}
|
|
void setGroupShared(void* grp_shared) {
|
mAlogsGroupSharedParams = grp_shared;
|
}
|
void* getGroupShared() {
|
return mAlogsGroupSharedParams;
|
}
|
virtual XCamReturn updateConfig(bool needSync) { return XCAM_RETURN_NO_ERROR; };
|
virtual RkAiqAlgoResCom* getPreProcRes() {
|
return mPreOutParam;
|
}
|
virtual RkAiqAlgoResCom* getProcProcRes() {
|
return mProcOutParam;
|
}
|
protected:
|
virtual void init() = 0;
|
virtual void deInit();
|
void waitSignal(rk_aiq_uapi_mode_sync_e sync = RK_AIQ_UAPI_MODE_DEFAULT);
|
void sendSignal(rk_aiq_uapi_mode_sync_e sync = RK_AIQ_UAPI_MODE_DEFAULT);
|
enum {
|
RKAIQ_CONFIG_COM_PREPARE,
|
RKAIQ_CONFIG_COM_PRE,
|
RKAIQ_CONFIG_COM_PROC,
|
RKAIQ_CONFIG_COM_POST,
|
};
|
virtual XCamReturn configInparamsCom(RkAiqAlgoCom* com, int type);
|
RkAiqAlgoCom* mConfig;
|
RkAiqAlgoCom* mPreInParam;
|
RkAiqAlgoResCom* mPreOutParam;
|
RkAiqAlgoCom* mProcInParam;
|
RkAiqAlgoResCom* mProcOutParam;
|
RkAiqAlgoCom* mPostInParam;
|
RkAiqAlgoResCom* mPostOutParam;
|
const RkAiqAlgoDesComm* mDes;
|
RkAiqAlgoContext* mAlgoCtx;
|
RkAiqCore* mAiqCore;
|
bool mEnable;
|
bool mReConfig;
|
uint32_t mGroupId;
|
void* mAlogsGroupSharedParams;
|
XCam::Mutex mCfgMutex;
|
mutable std::atomic<bool> updateAtt;
|
XCam::Cond mUpdateCond;
|
RkAiqHandle* mNextHdl;
|
RkAiqHandle* mParentHdl;
|
bool mIsMulRun;
|
bool mPostShared;
|
};
|
|
template <typename T>
|
RkAiqHandle* createT(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore) {
|
return new T(des, aiqCore);
|
}
|
|
struct RkAiqHandleFactory {
|
typedef std::map<std::string, RkAiqHandle* (*)(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)>
|
map_type;
|
|
~RkAiqHandleFactory() {
|
if (map != nullptr) {
|
if (map->empty()) {
|
delete map;
|
}
|
}
|
}
|
|
static RkAiqHandle* createInstance(std::string const& s, RkAiqAlgoDesComm* des,
|
RkAiqCore* aiqCore) {
|
map_type::iterator it = getMap()->find(s);
|
if (it == getMap()->end()) return 0;
|
return it->second(des, aiqCore);
|
}
|
|
protected:
|
static map_type* getMap() {
|
// never delete'ed. (exist until program termination)
|
// because we can't guarantee correct destruction order
|
if (!map) {
|
map = new map_type;
|
}
|
return map;
|
}
|
|
private:
|
static map_type* map;
|
};
|
|
template <typename T>
|
struct RkAiqHandleRegister : RkAiqHandleFactory {
|
RkAiqHandleRegister(std::string const& s) : s_(s) { getMap()->insert(std::make_pair(s, &createT<T>)); }
|
~RkAiqHandleRegister() { getMap()->erase(s_); }
|
private:
|
const std::string s_;
|
};
|
|
#define DECLARE_HANDLE_REGISTER_TYPE(NAME) static RkAiqHandleRegister<NAME> reg
|
|
#define DEFINE_HANDLE_REGISTER_TYPE(NAME) RkAiqHandleRegister<NAME> NAME::reg(#NAME)
|
|
}; // namespace RkCam
|
|
#endif
|
