/*
|
* 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.
|
*/
|
|
#include "RkAiqAmdHandle.h"
|
|
#include "RkAiqCore.h"
|
#include "common/media_buffer/media_buffer.h"
|
|
namespace RkCam {
|
|
DEFINE_HANDLE_REGISTER_TYPE(RkAiqAmdHandleInt);
|
|
XCamReturn RkAiqAmdHandleInt::prepare() {
|
ENTER_ANALYZER_FUNCTION();
|
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
ret = RkAiqHandle::prepare();
|
RKAIQCORE_CHECK_RET(ret, "amd handle prepare failed");
|
|
RkAiqAlgoConfigAmd* amd_config_int = (RkAiqAlgoConfigAmd*)mConfig;
|
RkAiqCore::RkAiqAlgosGroupShared_t* shared =
|
(RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
|
RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
|
|
amd_config_int->spWidth = sharedCom->spWidth;
|
amd_config_int->spHeight = sharedCom->spHeight;
|
amd_config_int->spAlignedW = sharedCom->spAlignedWidth;
|
amd_config_int->spAlignedH = sharedCom->spAlignedHeight;
|
|
RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
|
ret = des->prepare(mConfig);
|
RKAIQCORE_CHECK_RET(ret, "amd algo prepare failed");
|
|
EXIT_ANALYZER_FUNCTION();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
void RkAiqAmdHandleInt::init() {
|
ENTER_ANALYZER_FUNCTION();
|
|
RkAiqHandle::deInit();
|
mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAmd());
|
mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAmd());
|
mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAmd());
|
mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAmd());
|
// mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAmd());
|
mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAmd());
|
mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAmd());
|
|
EXIT_ANALYZER_FUNCTION();
|
}
|
|
XCamReturn RkAiqAmdHandleInt::updateConfig(bool needSync) { return XCAM_RETURN_NO_ERROR; }
|
|
XCamReturn RkAiqAmdHandleInt::preProcess() {
|
ENTER_ANALYZER_FUNCTION();
|
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
RkAiqAlgoPreAmd* amd_pre_int = (RkAiqAlgoPreAmd*)mPreInParam;
|
RkAiqAlgoPreResAmd* amd_pre_res_int = (RkAiqAlgoPreResAmd*)mPreOutParam;
|
RkAiqCore::RkAiqAlgosGroupShared_t* shared =
|
(RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
|
RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
|
|
ret = RkAiqHandle::preProcess();
|
if (ret) {
|
RKAIQCORE_CHECK_RET(ret, "amd handle preProcess failed");
|
}
|
|
RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
|
ret = des->pre_process(mPreInParam, mPreOutParam);
|
RKAIQCORE_CHECK_RET(ret, "amd algo pre_process failed");
|
|
EXIT_ANALYZER_FUNCTION();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn RkAiqAmdHandleInt::processing() {
|
ENTER_ANALYZER_FUNCTION();
|
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
RkAiqAlgoProcAmd* amd_proc_int = (RkAiqAlgoProcAmd*)mProcInParam;
|
|
mProcResShared = new RkAiqAlgoProcResAmdIntShared();
|
if (!mProcResShared.ptr()) {
|
LOGE("new amd mProcOutParam failed, bypass!");
|
return XCAM_RETURN_BYPASS;
|
}
|
RkAiqAlgoProcResAmd* amd_proc_res_int = &mProcResShared->result;
|
|
RkAiqCore::RkAiqAlgosGroupShared_t* shared =
|
(RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
|
RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
|
|
ret = RkAiqHandle::processing();
|
if (ret) {
|
RKAIQCORE_CHECK_RET(ret, "amd handle processing failed");
|
}
|
|
memset(&amd_proc_res_int->amd_proc_res, 0,
|
sizeof(amd_proc_res_int->amd_proc_res));
|
amd_proc_int->stats.spImage = shared->sp;
|
amd_proc_int->stats.ispGain = shared->ispGain;
|
RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
|
ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)amd_proc_res_int);
|
RKAIQCORE_CHECK_RET(ret, "amd algo processing failed");
|
|
MediaBuffer_t* mbuf = amd_proc_res_int->amd_proc_res.st_ratio;
|
if (mbuf) {
|
MotionBufMetaData_t* metadata = (MotionBufMetaData_t*)mbuf->pMetaData;
|
SmartPtr<BufferProxy> msg_data = new BufferProxy(mProcResShared);
|
msg_data->set_sequence(shared->frameId);
|
SmartPtr<XCamMessage> msg =
|
new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AMD_PROC_RES_OK, metadata->frame_id, msg_data);
|
mAiqCore->post_message(msg);
|
}
|
|
EXIT_ANALYZER_FUNCTION();
|
return ret;
|
}
|
|
XCamReturn RkAiqAmdHandleInt::postProcess() {
|
ENTER_ANALYZER_FUNCTION();
|
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
RkAiqAlgoPostAmd* amd_post_int = (RkAiqAlgoPostAmd*)mPostInParam;
|
RkAiqAlgoPostResAmd* amd_post_res_int = (RkAiqAlgoPostResAmd*)mPostOutParam;
|
RkAiqCore::RkAiqAlgosGroupShared_t* shared =
|
(RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
|
RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
|
|
ret = RkAiqHandle::postProcess();
|
if (ret) {
|
RKAIQCORE_CHECK_RET(ret, "amd handle postProcess failed");
|
return ret;
|
}
|
|
RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
|
ret = des->post_process(mPostInParam, mPostOutParam);
|
RKAIQCORE_CHECK_RET(ret, "amd algo post_process failed");
|
|
EXIT_ANALYZER_FUNCTION();
|
return ret;
|
}
|
|
XCamReturn RkAiqAmdHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
|
ENTER_ANALYZER_FUNCTION();
|
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
RkAiqCore::RkAiqAlgosGroupShared_t* shared =
|
(RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
|
RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
|
RkAiqAlgoProcResAmd* amd_com = &mProcResShared->result;
|
|
rk_aiq_isp_md_params_v20_t* md_param = params->mMdParams->data().ptr();
|
if (sharedCom->init) {
|
md_param->frame_id = 0;
|
} else {
|
md_param->frame_id = shared->frameId;
|
}
|
|
if (!amd_com) {
|
LOGD_ANALYZER("no amd result");
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
md_param->result = amd_com->amd_proc_res;
|
|
if (!this->getAlgoId()) {
|
RkAiqAlgoProcResAmd* amd_rk = (RkAiqAlgoProcResAmd*)amd_com;
|
}
|
|
cur_params->mMdParams = params->mMdParams;
|
|
EXIT_ANALYZER_FUNCTION();
|
|
return ret;
|
}
|
|
}; // namespace RkCam
|
