| /* |
| * Copyright (C) 2019 MediaTek Inc. |
| * |
| * 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. |
| */ |
| |
| #define LOG_TAG "MtkCam/P1NodeImp" |
| // |
| #include <memory> |
| #include "mtkcam/pipeline/hwnode/p1/P1RegisterNotify.h" |
| #include "P1TaskCtrl.h" |
| #include "P1NodeImp.h" |
| #include <vector> |
| |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| namespace NSCam { |
| namespace v3 { |
| namespace NSP1Node { |
| |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // P1NotifyCrop |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| void P1NotifyCrop::p1TuningNotify(MVOID* pIn, MVOID* pOut) { |
| if (mspP1Notify != nullptr) { |
| mspP1Notify->doNotifyCrop(pIn, pOut); |
| } |
| return; |
| } |
| |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // P1NotifyQuality |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| void P1NotifyQuality::p1TuningNotify(MVOID* pIn, MVOID* pOut) { |
| if (mspP1Notify != nullptr) { |
| mspP1Notify->doNotifyQuality(pIn, pOut); |
| } |
| return; |
| } |
| |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // P1RegisterNotify |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| P1RegisterNotify::P1RegisterNotify(std::shared_ptr<P1NodeImp> spP1NodeImp) |
| : mspP1NodeImp(spP1NodeImp), |
| mOpenId(-1), |
| mLogLevel(0), |
| mLogLevelI(0), |
| mBurstNum(1), |
| mpNotifyCrop(nullptr), |
| mpNotifyQuality(nullptr) { |
| config(); |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| P1RegisterNotify::~P1RegisterNotify() {} |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1RegisterNotify::init() { |
| MY_LOGD("+++"); |
| uninit(); |
| // |
| if (mpNotifyCrop == nullptr) { |
| mpNotifyCrop = std::make_shared<P1NotifyCrop>(shared_from_this()); |
| } |
| // |
| if (mpNotifyQuality == nullptr) { |
| mpNotifyQuality = std::make_shared<P1NotifyQuality>(shared_from_this()); |
| } |
| // |
| MY_LOGD("---"); |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1RegisterNotify::uninit() { |
| MY_LOGD("+++"); |
| // |
| mpNotifyCrop = nullptr; |
| mpNotifyQuality = nullptr; |
| // |
| MY_LOGD("---"); |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1RegisterNotify::config() { |
| if (mspP1NodeImp != nullptr) { |
| mOpenId = mspP1NodeImp->getOpenId(); |
| mLogLevel = mspP1NodeImp->mLogLevel; |
| mLogLevelI = mspP1NodeImp->mLogLevelI; |
| if (mspP1NodeImp->mBurstNum > 1) { |
| mBurstNum = mspP1NodeImp->mBurstNum; |
| } |
| } |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1RegisterNotify::doNotifyCrop(MVOID* pIn, MVOID* pOut) { |
| if (CC_UNLIKELY(mspP1NodeImp == nullptr)) { |
| MY_LOGE("P1NodeImp not exist"); |
| return; |
| } |
| if (CC_UNLIKELY(pIn == nullptr || pOut == nullptr)) { |
| MY_LOGE("NotifyCrop In/Out NULL - In[%p] Out[%p]", pIn, pOut); |
| return; |
| } |
| MY_LOGI("NotifyCrop - In[%p] Out[%p]", pIn, pOut); |
| BIN_INPUT_INFO* pInInfo = reinterpret_cast<BIN_INPUT_INFO*>(pIn); |
| RRZ_REG_CFG* pOutCfg = reinterpret_cast<RRZ_REG_CFG*>(pOut); |
| MSize curSize = MSize(pInInfo->TarBinOut_W, pInInfo->TarBinOut_H); |
| // |
| mspP1NodeImp->setCurrentBinSize(curSize); |
| pOutCfg->bRRZ_Bypass = MTRUE; |
| // |
| { |
| // if (pInInfo != NULL && pOutCfg != NULL) // no need to check since the |
| // pIn/pOut has checked |
| MBOOL found = MFALSE; |
| std::lock_guard<std::mutex> _l(mspP1NodeImp->mProcessingQueueLock); |
| if (mspP1NodeImp->mProcessingQueue.empty()) { |
| MY_LOGI("ProcessingQueue is empty num:%d", (MINT32)pInInfo->Magic); |
| return; |
| } |
| P1QueAct qAct; |
| std::vector<P1QueJob>::iterator it_job = |
| mspP1NodeImp->mProcessingQueue.begin(); |
| for (; it_job != mspP1NodeImp->mProcessingQueue.end(); it_job++) { |
| for (size_t i = 0; i < it_job->size(); i++) { |
| if (it_job->edit(i).getNum() == (MINT32)pInInfo->Magic) { |
| qAct = it_job->edit(i); |
| found = MTRUE; |
| break; |
| } |
| } |
| } |
| |
| if (found) { |
| if (qAct.getNum() != P1ACT_NUM_NULL) { |
| P1Act act = GET_ACT_PTR(act, qAct, RET_VOID); |
| MBOOL isSetChange = MFALSE; |
| MBOOL isSizeChange = (act->refBinSize == curSize) ? MFALSE : MTRUE; |
| // if (IS_BURST_OFF) // exclude burst mode |
| mspP1NodeImp->attemptCtrlResize(&qAct, &isSetChange); |
| if (isSetChange || isSizeChange) { |
| MY_LOGI( |
| "Resize Change set(%d) size(%d) cur" P1_SIZE_STR "ref" P1_SIZE_STR |
| "crop" P1_RECT_STR "dst" P1_SIZE_STR "MaxRatio(%d)", |
| isSetChange, isSizeChange, P1_SIZE_VAR(curSize), |
| P1_SIZE_VAR(act->refBinSize), P1_RECT_VAR(act->cropRect_resizer), |
| P1_SIZE_VAR(act->dstSize_resizer), mspP1NodeImp->mResizeRatioMax); |
| if (act->refBinSize.w > curSize.w) { |
| BIN_RESIZE(act->cropRect_resizer.p.x); |
| BIN_RESIZE(act->cropRect_resizer.p.y); |
| BIN_RESIZE(act->cropRect_resizer.s.w); |
| BIN_RESIZE(act->cropRect_resizer.s.h); |
| } else if (act->refBinSize.w < curSize.w) { |
| BIN_REVERT(act->cropRect_resizer.p.x); |
| BIN_REVERT(act->cropRect_resizer.p.y); |
| BIN_REVERT(act->cropRect_resizer.s.w); |
| BIN_REVERT(act->cropRect_resizer.s.h); |
| } // for performance consideration, only check W |
| MY_LOGI("BIN check crop" P1_RECT_STR "dst" P1_SIZE_STR, |
| P1_RECT_VAR(act->cropRect_resizer), |
| P1_SIZE_VAR(act->dstSize_resizer)); |
| // |
| if (act->cropRect_resizer.s.w * mspP1NodeImp->mResizeRatioMax > |
| act->dstSize_resizer.w * 100) { |
| act->dstSize_resizer.w = |
| ((act->cropRect_resizer.s.w * mspP1NodeImp->mResizeRatioMax) + |
| (100 - 1)) / |
| 100; |
| act->dstSize_resizer.w = ALIGN_UPPER(act->dstSize_resizer.w, 2); |
| } else if (act->cropRect_resizer.s.w < act->dstSize_resizer.w) { |
| act->dstSize_resizer.w = act->cropRect_resizer.s.w; |
| } |
| // |
| if (act->cropRect_resizer.s.h * mspP1NodeImp->mResizeRatioMax > |
| act->dstSize_resizer.h * 100) { |
| act->dstSize_resizer.h = |
| ((act->cropRect_resizer.s.h * mspP1NodeImp->mResizeRatioMax) + |
| (100 - 1)) / |
| 100; |
| act->dstSize_resizer.h = ALIGN_UPPER(act->dstSize_resizer.h, 2); |
| } else if (act->cropRect_resizer.s.h < act->dstSize_resizer.h) { |
| act->dstSize_resizer.h = act->cropRect_resizer.s.h; |
| } |
| MY_LOGI("LMT check crop" P1_RECT_STR "dst" P1_SIZE_STR, |
| P1_RECT_VAR(act->cropRect_resizer), |
| P1_SIZE_VAR(act->dstSize_resizer)); |
| { |
| // if (IS_BURST_OFF) // exclude burst mode |
| pOutCfg->bRRZ_Bypass = MFALSE; |
| pOutCfg->src_x = act->cropRect_resizer.p.x; |
| pOutCfg->src_y = act->cropRect_resizer.p.y; |
| pOutCfg->src_w = act->cropRect_resizer.s.w; |
| pOutCfg->src_h = act->cropRect_resizer.s.h; |
| pOutCfg->tar_w = act->dstSize_resizer.w; |
| pOutCfg->tar_h = act->dstSize_resizer.h; |
| MY_LOGI( |
| "Resize Change set(%d) size(%d) End -" |
| "OutCfg[Bypass:%d src(%d,%d-%dx%d) tar(%dx%d)]", |
| isSetChange, isSizeChange, pOutCfg->bRRZ_Bypass, pOutCfg->src_x, |
| pOutCfg->src_y, pOutCfg->src_w, pOutCfg->src_h, pOutCfg->tar_w, |
| pOutCfg->tar_h); |
| } |
| } |
| } |
| } else { |
| MY_LOGW("Notify Frame Not Found - Drv(%d)", pInInfo->Magic); |
| size_t amount = mspP1NodeImp->mProcessingQueue.size(); |
| MUINT32 i = 0; |
| std::vector<P1QueJob>::iterator it = |
| mspP1NodeImp->mProcessingQueue.begin(); |
| for (; it != mspP1NodeImp->mProcessingQueue.end(); it++, i++) { |
| MY_LOGW("ProcessingQueue[%d/%zu] = job(%d-%d)", i, amount, |
| (*it).getIdx(), (*it).getLastNum()); |
| } |
| } |
| } |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1RegisterNotify::doNotifyQuality(MVOID* pIn, MVOID* pOut) { |
| if (CC_UNLIKELY(mspP1NodeImp == nullptr)) { |
| MY_LOGE("P1NodeImp not exist"); |
| return; |
| } |
| MY_LOGI("NotifyQuality - In[%p] Out[%p]", pIn, pOut); |
| // |
| mspP1NodeImp->setQualitySwitching(MFALSE); |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID* P1RegisterNotify::getNotifyCrop() { |
| if (CC_UNLIKELY(mpNotifyCrop == nullptr)) { |
| MY_LOGE("NotifyCrop not exist"); |
| } |
| return reinterpret_cast<MVOID*>(mpNotifyCrop.get()); |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID* P1RegisterNotify::getNotifyQuality() { |
| if (CC_UNLIKELY(mpNotifyQuality == nullptr)) { |
| MY_LOGE("NotifyQuality not exist"); |
| } |
| return reinterpret_cast<MVOID*>(mpNotifyQuality.get()); |
| } |
| |
| }; // namespace NSP1Node |
| }; // namespace v3 |
| }; // namespace NSCam |
