| /* |
| * 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 <algorithm> |
| #include <memory> |
| #include "mtkcam/pipeline/hwnode/p1/P1NodeImp.h" |
| #include "P1TaskCtrl.h" |
| #include "P1DeliverMgr.h" |
| #include <mtkcam/aaa/aaa_utils.h> |
| #include <mtkcam/feature/eis/EisInfo.h> |
| #include <mtkcam/utils/hw/HwTransform.h> |
| #include <property_lib.h> |
| #include <string> |
| #include <vector> |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| namespace NSCam { |
| namespace v3 { |
| namespace NSP1Node { |
| |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| P1NodeImp::P1NodeImp() |
| : BaseNode(), |
| P1Node(), |
| mInit(MTRUE) |
| // |
| , |
| mPowerNotify(MFALSE) |
| // |
| , |
| mStartState(NSP1Node::START_STATE_NULL) |
| // |
| , |
| mpStreamPool_full(nullptr), |
| mpStreamPool_resizer(nullptr), |
| mpStreamPool_lcso(nullptr), |
| mpStreamPool_rsso(nullptr), |
| mBurstNum(1), |
| mDepthNum(1), |
| mMeta_PatMode(0), |
| mRawPostProcSupport(MTRUE), |
| mRawProcessed(MFALSE), |
| mRawSetDefType(RAW_DEF_TYPE_AUTO), |
| mRawDefType(EPipe_PURE_RAW), |
| mRawOption(0), |
| mDisableFrontalBinning(MFALSE), |
| mDisableDynamicTwin(MFALSE), |
| mEnableLCSO(MFALSE), |
| mEnableRSSO(MFALSE), |
| mEnableUniForcedOn(MFALSE), |
| mDisableHLR(MFALSE), |
| mPipeMode(PIPE_MODE_NORMAL), |
| mPipeBit(CAM_Pipeline_12BITS), |
| mResizeQuality(RESIZE_QUALITY_UNKNOWN), |
| mTgNum(0) |
| // |
| , |
| mRawFormat(P1_IMGO_DEF_FMT), |
| mRawStride(0), |
| mRawLength(0) |
| // |
| , |
| mReceiveMode(REV_MODE_NORMAL), |
| mSensorFormatOrder(SENSOR_FORMAT_ORDER_NONE), |
| mQualitySwitching(MFALSE), |
| m3AProcessedDepth(3), |
| mNumHardwareBuffer(3), |
| mDelayframe(3), |
| mLastNum(1), |
| mLastSofIdx(P1SOFIDX_NULL_VAL), |
| mLastSetNum(0), |
| mActive(MFALSE), |
| mReady(MFALSE) |
| #if (USING_DRV_IO_PIPE_EVENT) |
| , |
| mIoPipeEvtState(IO_PIPE_EVT_STATE_NONE), |
| mIoPipeEvtWaiting(MFALSE), |
| mIoPipeEvtOpAcquired(MFALSE), |
| mIoPipeEvtOpLeaving(MFALSE), |
| mspIoPipeEvtHandleAcquire(nullptr), |
| mspIoPipeEvtHandleRelease(nullptr) |
| #endif |
| , |
| mCamIOVersion(0), |
| mpCamIO(nullptr), |
| mp3A(nullptr), |
| mpLCS(nullptr) |
| // |
| , |
| mPixelMode(0) |
| // |
| , |
| mConfigPort(CONFIG_PORT_NONE), |
| mConfigPortNum(0), |
| mIsBinEn(MFALSE), |
| mIsDynamicTwinEn(MFALSE), |
| mIsLegacyStandbyMode(MFALSE), |
| mForceStandbyMode(0) |
| // |
| , |
| mResizeRatioMax(RESIZE_RATIO_MAX_100X) |
| // |
| , |
| mLastFrmReqNumLock(), |
| mLastFrmNum(P1_FRM_NUM_NULL), |
| mLastReqNum(P1_REQ_NUM_NULL), |
| mLastCbCnt(0) |
| // |
| , |
| mMonitorTime(0) |
| // |
| , |
| mDebugScanLineMask(0), |
| mpDebugScanLine(nullptr) |
| // |
| , |
| mIvMs(0), |
| mpIndependentVerification(nullptr) |
| // |
| , |
| mFrameSetAlready(MFALSE) |
| // |
| , |
| mFirstReceived(MFALSE) |
| // |
| , |
| mStartCaptureState(START_CAP_STATE_NONE), |
| mStartCaptureType(NS3Av3::E_CAPTURE_NORMAL), |
| mStartCaptureIdx(0), |
| mStartCaptureExp(0), |
| mTransferJobIdx(P1ACT_ID_NULL), |
| mTransferJobWaiting(MFALSE) |
| // |
| // |
| , |
| mDequeThreadProfile("P1Node::deque", 30000000LL), |
| mInFlightRequestCnt(0) |
| // |
| , |
| mpDeliverMgr(nullptr) |
| // |
| , |
| mpConnectLMV(NULL) |
| // |
| , |
| mpConCtrl(nullptr) |
| // |
| , |
| mpHwStateCtrl(nullptr) |
| // |
| , |
| mpTimingCheckerMgr(nullptr), |
| mTimingFactor(1) |
| // |
| , |
| mspSyncHelper(nullptr), |
| mSyncHelperReady(MFALSE) |
| // |
| , |
| mspResConCtrl(nullptr), |
| mResConClient(IResourceConcurrency::CLIENT_HANDLER_NULL), |
| mIsResConGot(MFALSE) |
| // |
| // |
| , |
| mLogLevel(0), |
| mLogLevelI(0), |
| mSysLevel(P1_SYS_LV_DEFAULT), |
| mMetaLogOp(0), |
| mMetaLogTag(0), |
| mCamDumpEn(0), |
| mEnableDumpRaw(0), |
| mDisableAEEIS(0) |
| // |
| , |
| mNoteRelease(P1NODE_FRAME_NOTE_SLOT_SIZE_DEF), |
| mNoteDispatch(P1NODE_FRAME_NOTE_SLOT_SIZE_DEF) |
| // |
| , |
| mInitReqSet(0), |
| mInitReqNum(0), |
| mInitReqCnt(0), |
| mInitReqOff(MFALSE) |
| // |
| , |
| mEnableCaptureFlow(MFALSE), |
| mEnableFrameSync(MFALSE), |
| mExitPending(MFALSE) { |
| pthread_rwlock_init(&mConfigRWLock, NULL); |
| #if (USING_DRV_IO_PIPE_EVENT) |
| pthread_rwlock_init(&mIoPipeEvtStateLock, NULL); |
| #endif |
| mNodeName = "P1Node"; // default name |
| MINT32 cam_log = ::property_get_int32("vendor.debug.camera.log", 0); |
| MINT32 p1_log = ::property_get_int32("vendor.debug.camera.log.p1node", 1); |
| MINT32 p1_logi = ::property_get_int32("vendor.debug.camera.log.p1nodei", 0); |
| MINT32 g_log = ::property_get_int32("persist.vendor.mtk.camera.log_level", |
| 0); // global log level control |
| MINT32 g_log_lv = |
| (g_log >= 2) ? (g_log - 2) : (0); // 2:I:USER 3:D:USERDEBUG 4:V:ENG |
| mLogLevel = MAX(cam_log, p1_log); |
| #if 0 // force to enable all p1 node log |
| #warning "[FIXME] force to enable P1Node log" |
| if (mLogLevel < 2) { |
| mLogLevel = 2; |
| } |
| #endif |
| MBOOL buildLogD = MFALSE; |
| MBOOL buildLogI = MFALSE; |
| #if (IS_P1_LOGI) |
| // #warning "IS_P1_LOGI build LogI" |
| mLogLevelI = (mLogLevel > 0) ? (mLogLevel - 1) : (mLogLevel); |
| buildLogI = MTRUE; |
| #endif |
| #if (IS_P1_LOGD) |
| // #warning "IS_P1_LOGD build LogD" |
| mLogLevelI = mLogLevel; |
| buildLogD = MTRUE; |
| #endif |
| if (p1_log > 1) { |
| mLogLevelI = mLogLevel; |
| } |
| // |
| if (p1_logi > 0) { |
| mLogLevelI = p1_logi; |
| } |
| mLogLevel = MAX(mLogLevel, g_log_lv); |
| mLogLevelI = MAX(mLogLevelI, g_log_lv); |
| // |
| MINT32 g_sys = P1_SYS_LV_DEFAULT; |
| MINT32 g_sys_set = 1; |
| #if 1 // decide by global-setting |
| g_sys_set = ::property_get_int32("vendor.debug.mtkcam.systrace.level", |
| MTKCAM_SYSTRACE_LEVEL_DEFAULT); |
| #endif |
| g_sys = (g_sys_set > 0) ? P1_SYS_LV_DEFAULT : P1_SYS_LV_CRITICAL; |
| mSysLevel = g_sys; |
| MINT32 p1sys = ::property_get_int32("vendor.debug.camera.log.p1nodesys", 9); |
| if (p1sys < 9) { // update by manual-setting |
| // =0 : forced-off all P1_TRACE |
| // =1 : basic-on P1_TRACE-Lv==1 (P1_SYS_LV_BASIC) |
| // =2 : critical-on P1_TRACE-Lv<=2 (P1_SYS_LV_CRITICAL) |
| // =3 : default-on P1_TRACE-Lv<=3 (P1_SYS_LV_DEFAULT) |
| // >3 : manually-on |
| mSysLevel = p1sys; |
| } |
| // |
| MINT32 pMetaLogOp = |
| property_get_int32("vendor.debug.camera.log.p1nodemeta", 0); |
| MINT32 pMetaLogTag = |
| property_get_int32("vendor.debug.camera.log.p1nodemetatag", 0); |
| mMetaLogOp = pMetaLogOp; |
| mMetaLogTag = pMetaLogTag; |
| if (mMetaLogTag != 0) { |
| mMetaLogOp = 1; |
| } |
| // |
| mCamDumpEn = property_get_int32("vendor.debug.camera.dump.en", 0); |
| // |
| mEnableDumpRaw = |
| property_get_int32("vendor.debug.feature.forceEnableIMGO", 0); |
| // |
| mDisableAEEIS = property_get_int32("vendor.debug.eis.disableae", 0); |
| // |
| mDebugScanLineMask = |
| ::property_get_int32("vendor.debug.camera.scanline.p1", 0); |
| if (mDebugScanLineMask != 0) { |
| mpDebugScanLine = std::make_unique<DebugScanLineImp>(); |
| } |
| // |
| mIvMs = property_get_int32( |
| "vendor.debug.camera.log.p1independentverification", 0); |
| // |
| #if (SUPPORT_BUFFER_TUNING_DUMP) |
| MY_LOGI("SUPPORT_BUFFER_TUNING_DUMP CamDumpEn(%d)", mCamDumpEn); |
| #else |
| if (mCamDumpEn > 0) { |
| MY_LOGI("NOT-SUPPORT_BUFFER_TUNING_DUMP CamDumpEn(%d)", mCamDumpEn); |
| } |
| mCamDumpEn = 0; |
| #endif |
| // |
| #if (P1NODE_BUILD_LOG_LEVEL_DEFAULT > 3) |
| mTimingFactor = 32; // for ENG build |
| #elif P1NODE_BUILD_LOG_LEVEL_DEFAULT > 2 |
| mTimingFactor = 2; // for USERDEBUG build |
| #else |
| mTimingFactor = 1; // for USER build |
| mIvMs = 0; |
| #endif |
| // |
| MY_LOGI( |
| "LOGD[%d](%d) LOGI[%d](%d) prop(cam:%d pl:%d pi:%d g:%d:%d) - " |
| " SYS[%d-%d:%d](%d) - " |
| "MetaLog(p:%d/%d m:%d/x%X) DumpRaw(%d) DataDump(%d) DrawLine(%d) - " |
| "TF(%d) - IV(%d)", |
| buildLogD, mLogLevel, buildLogI, mLogLevelI, cam_log, p1_log, p1_logi, |
| g_log, g_log_lv, g_sys_set, g_sys, p1sys, mSysLevel, pMetaLogOp, |
| pMetaLogTag, mMetaLogOp, mMetaLogTag, mEnableDumpRaw, mCamDumpEn, |
| mDebugScanLineMask, mTimingFactor, mIvMs); |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| P1NodeImp::~P1NodeImp() { |
| MY_LOGI(""); |
| pthread_rwlock_destroy(&mConfigRWLock); |
| #if (USING_DRV_IO_PIPE_EVENT) |
| pthread_rwlock_destroy(&mIoPipeEvtStateLock); |
| #endif |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::init(InitParams const& rParams) { |
| FUNCTION_IN; |
| |
| P1_TRACE_AUTO(SLG_B, "P1:init"); |
| |
| std::lock_guard<std::mutex> _l(mPublicLock); |
| |
| { |
| pthread_rwlock_wrlock(&mConfigRWLock); |
| // |
| mOpenId = rParams.openId; |
| mNodeId = rParams.nodeId; |
| mNodeName = rParams.nodeName; |
| pthread_rwlock_unlock(&mConfigRWLock); |
| } |
| // |
| if (mIvMs > 0) { |
| mpIndependentVerification = |
| std::make_unique<P1NodeImp::IndependentVerification>( |
| mLogLevel, mLogLevelI, (MUINT32)mIvMs, shared_from_this()); |
| if (mpIndependentVerification == nullptr) { |
| MY_LOGE("IndependentVerification create fail"); |
| return NO_MEMORY; |
| } |
| } |
| // Select CamIO version |
| { |
| auto pModule = getNormalPipeModule(); |
| |
| if (!pModule) { |
| MY_LOGE("getNormalPipeModule() fail"); |
| return UNKNOWN_ERROR; |
| } |
| |
| MUINT32 const* version = nullptr; |
| size_t count = 0; |
| int err = pModule->get_sub_module_api_version(&version, &count); |
| if (err < 0 || !count || !version) { |
| MY_LOGE( |
| "[%d] INormalPipeModule::get_sub_module_api_version - err:%#x " |
| "count:%zu version:%p", |
| mOpenId, err, count, version); |
| return UNKNOWN_ERROR; |
| } |
| |
| mCamIOVersion = *(version + count - 1); // Select max. version |
| MY_LOGD("[%d] count:%zu Selected CamIO Version:%0#x", mOpenId, count, |
| mCamIOVersion); |
| } |
| |
| #if (USING_DRV_IO_PIPE_EVENT) |
| { |
| std::lock_guard<std::mutex> _l(mIoPipeEvtOpLock); |
| mIoPipeEvtOpLeaving = MFALSE; |
| NSCam::NSIoPipe::IoPipeEventSystem& evtSystem = |
| NSCam::NSIoPipe::IoPipeEventSystem::getGlobal(); |
| if (mspIoPipeEvtHandleAcquire != nullptr) { |
| mspIoPipeEvtHandleAcquire->unsubscribe(); |
| mspIoPipeEvtHandleAcquire = nullptr; |
| } |
| mspIoPipeEvtHandleAcquire = evtSystem.subscribe( |
| NSCam::NSIoPipe::EVT_IPRAW_P1_ACQUIRING, onEvtCtrlAcquiring, this); |
| if (mspIoPipeEvtHandleAcquire == nullptr) { |
| MY_LOGE("IoPipeEventSystem subscribe EVT_IPRAW_P1_ACQUIRING fail"); |
| return UNKNOWN_ERROR; |
| } |
| if (mspIoPipeEvtHandleRelease != nullptr) { |
| mspIoPipeEvtHandleRelease->unsubscribe(); |
| mspIoPipeEvtHandleRelease = nullptr; |
| } |
| mspIoPipeEvtHandleRelease = evtSystem.subscribe( |
| NSCam::NSIoPipe::EVT_IPRAW_P1_RELEASED, onEvtCtrlReleasing, this); |
| if (mspIoPipeEvtHandleRelease == nullptr) { |
| MY_LOGE("IoPipeEventSystem subscribe EVT_IPRAW_P1_RELEASED fail"); |
| return UNKNOWN_ERROR; |
| } |
| } |
| #endif |
| |
| mStuffBufMgr.setLog(getOpenId(), mLogLevel, mLogLevelI); |
| |
| mLongExp.config(getOpenId(), mLogLevel, mLogLevelI); |
| |
| mpConCtrl = |
| std::make_shared<ConcurrenceControl>(mLogLevel, mLogLevelI, mSysLevel); |
| if (mpConCtrl == nullptr || mpConCtrl->getStageCtrl() == nullptr) { |
| MY_LOGE("ConcurrenceControl create fail"); |
| return NO_MEMORY; |
| } |
| |
| mpHwStateCtrl = std::make_shared<HardwareStateControl>(); |
| if (mpHwStateCtrl == nullptr) { |
| MY_LOGE("HardwareStateControl create fail"); |
| return NO_MEMORY; |
| } |
| mpConnectLMV = std::make_shared<P1ConnectLMV>(getOpenId(), mLogLevel, |
| mLogLevelI, mSysLevel); |
| if (mpConnectLMV == NULL) { |
| MY_LOGE("ConnectLMV create fail Log(%d)(%d) Id(%d)", mLogLevel, mLogLevelI, |
| getOpenId()); |
| return NO_MEMORY; |
| } |
| mpTimingCheckerMgr = std::make_shared<TimingCheckerMgr>( |
| mTimingFactor, getOpenId(), mLogLevel, mLogLevelI); |
| if (mpTimingCheckerMgr == nullptr) { |
| MY_LOGE("TimingCheckerMgr create fail"); |
| return NO_MEMORY; |
| } |
| |
| mThread = std::thread(std::bind(&P1NodeImp::threadLoop, this)); |
| |
| mpDeliverMgr = std::make_shared<P1DeliverMgr>(); |
| if (mpDeliverMgr != nullptr) { |
| mpDeliverMgr->init(shared_from_this()); |
| } else { |
| MY_LOGE("DeliverMgr create fail"); |
| return NO_MEMORY; |
| } |
| |
| mpRegisterNotify = std::make_shared<P1RegisterNotify>(shared_from_this()); |
| if (mpRegisterNotify != nullptr) { |
| mpRegisterNotify->init(); |
| } else { |
| MY_LOGE("RegisterNotify create fail"); |
| return NO_MEMORY; |
| } |
| |
| mpTaskCtrl = std::make_shared<P1TaskCtrl>(shared_from_this()); |
| if (mpTaskCtrl == nullptr) { |
| MY_LOGE("TaskCtrl create fail"); |
| return NO_MEMORY; |
| } |
| |
| mpTaskCollector = std::make_shared<P1TaskCollector>(mpTaskCtrl); |
| if (mpTaskCollector == nullptr) { |
| MY_LOGE("TaskCollector create fail"); |
| return NO_MEMORY; |
| } |
| |
| mpAccDetector = std::make_unique<cros::NSCam::AccelerationDetector>(); |
| mpAccDetector->prepare(); |
| |
| FUNCTION_OUT; |
| |
| return NO_ERROR; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::uninit() { |
| FUNCTION_IN; |
| |
| P1_TRACE_AUTO(SLG_B, "P1:uninit"); |
| |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_API_UNINIT_BGN, |
| LogInfo::CP_API_UNINIT_END); |
| |
| #if (USING_DRV_IO_PIPE_EVENT) |
| { |
| std::lock_guard<std::mutex> _l(mIoPipeEvtOpLock); |
| mIoPipeEvtOpLeaving = MTRUE; |
| if (mspIoPipeEvtHandleAcquire != nullptr) { |
| mspIoPipeEvtHandleAcquire->unsubscribe(); |
| mspIoPipeEvtHandleAcquire = nullptr; |
| } |
| if (mspIoPipeEvtHandleRelease != nullptr) { |
| mspIoPipeEvtHandleRelease->unsubscribe(); |
| mspIoPipeEvtHandleRelease = nullptr; |
| } |
| } |
| #endif |
| |
| std::lock_guard<std::mutex> _l(mPublicLock); |
| |
| // flush the left frames if exist |
| onHandleFlush(MFALSE); |
| |
| requestExit(); |
| |
| // mvStreamMeta.clear(); |
| for (int stream = STREAM_ITEM_START; stream < STREAM_META_NUM; stream++) { |
| mvStreamMeta[stream] = nullptr; |
| } |
| |
| // mvStreamImg.clear(); |
| for (int stream = STREAM_ITEM_START; stream < STREAM_IMG_NUM; stream++) { |
| mvStreamImg[stream] = nullptr; |
| } |
| |
| mspSyncHelper = nullptr; |
| |
| if (mspResConCtrl != nullptr) { |
| P1NODE_RES_CON_RETURN(mspResConCtrl, mResConClient); |
| mspResConCtrl = nullptr; |
| } |
| |
| if (mpDeliverMgr != nullptr) { |
| mpDeliverMgr->uninit(); |
| mpDeliverMgr = nullptr; |
| } |
| |
| if (mpRegisterNotify != nullptr) { |
| mpRegisterNotify->uninit(); |
| mpRegisterNotify = nullptr; |
| } |
| |
| mpTaskCollector = nullptr; |
| |
| mpTaskCtrl = nullptr; |
| |
| mpTimingCheckerMgr = nullptr; |
| |
| mpHwStateCtrl = nullptr; |
| |
| mpConCtrl = nullptr; |
| |
| FUNCTION_OUT; |
| |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::check_config(ConfigParams const& rParams) { |
| P1_TRACE_AUTO(SLG_S, "P1:check_config"); |
| |
| if (rParams.pInAppMeta == nullptr) { |
| MY_LOGE("in app metadata is null"); |
| return BAD_VALUE; |
| } |
| |
| if (rParams.pInHalMeta == nullptr) { |
| MY_LOGE("in hal metadata is null"); |
| return BAD_VALUE; |
| } |
| |
| if (rParams.pOutAppMeta == nullptr) { |
| MY_LOGE("out app metadata is null"); |
| return BAD_VALUE; |
| } |
| |
| if (rParams.pOutHalMeta == nullptr) { |
| MY_LOGE("out hal metadata is null"); |
| return BAD_VALUE; |
| } |
| |
| if (rParams.pvOutImage_full.size() == 0 && |
| rParams.pOutImage_resizer == nullptr) { |
| MY_LOGE("image is empty"); |
| return BAD_VALUE; |
| } |
| |
| if (rParams.pStreamPool_full != nullptr && |
| rParams.pvOutImage_full.size() == 0) { |
| MY_LOGE("wrong full input"); |
| return BAD_VALUE; |
| } |
| |
| if (rParams.pStreamPool_resizer != nullptr && |
| rParams.pOutImage_resizer == nullptr) { |
| MY_LOGE("wrong resizer input"); |
| return BAD_VALUE; |
| } |
| |
| if (rParams.pStreamPool_lcso != nullptr && |
| rParams.pOutImage_lcso == nullptr) { |
| MY_LOGE("wrong resizer input"); |
| return BAD_VALUE; |
| } |
| |
| if (rParams.enableLCS == MTRUE && rParams.pOutImage_lcso == nullptr) { |
| MY_LOGE("wrong resizer input"); |
| return BAD_VALUE; |
| } |
| // |
| if (mpDeliverMgr != nullptr && mpDeliverMgr->runningGet() /*isRunning()*/) { |
| MY_LOGI("DeliverMgr thread is running"); |
| mpDeliverMgr->requestExit(); |
| mpDeliverMgr->trigger(); |
| mpDeliverMgr->join(); |
| mpDeliverMgr->runningSet(MFALSE); |
| } |
| |
| // Get sensor format |
| IHalSensorList* const pIHalSensorList = GET_HalSensorList(); |
| if (pIHalSensorList) { |
| MUINT32 sensorDev = |
| (MUINT32)pIHalSensorList->querySensorDevIdx(getOpenId()); |
| |
| NSCam::SensorStaticInfo sensorStaticInfo; |
| memset(&sensorStaticInfo, 0, sizeof(NSCam::SensorStaticInfo)); |
| pIHalSensorList->querySensorStaticInfo(sensorDev, &sensorStaticInfo); |
| mSensorFormatOrder = sensorStaticInfo.sensorFormatOrder; |
| MY_LOGI("SensorFormatOrder %d", mSensorFormatOrder); |
| } |
| |
| // |
| { |
| pthread_rwlock_wrlock(&mConfigRWLock); |
| // |
| for (int meta = STREAM_ITEM_START; meta < STREAM_META_NUM; meta++) { |
| mvStreamMeta[meta] = nullptr; |
| } |
| if (rParams.pInAppMeta != nullptr) { |
| mvStreamMeta[STREAM_META_IN_APP] = rParams.pInAppMeta; |
| } |
| if (rParams.pInHalMeta != nullptr) { |
| mvStreamMeta[STREAM_META_IN_HAL] = rParams.pInHalMeta; |
| } |
| if (rParams.pOutAppMeta != nullptr) { |
| mvStreamMeta[STREAM_META_OUT_APP] = rParams.pOutAppMeta; |
| } |
| if (rParams.pOutHalMeta != nullptr) { |
| mvStreamMeta[STREAM_META_OUT_HAL] = rParams.pOutHalMeta; |
| } |
| // |
| for (int img = STREAM_ITEM_START; img < STREAM_IMG_NUM; img++) { |
| mvStreamImg[img] = nullptr; |
| } |
| // |
| if (rParams.pInImage_yuv != nullptr) { |
| mvStreamImg[STREAM_IMG_IN_YUV] = rParams.pInImage_yuv; |
| } |
| if (rParams.pInImage_opaque != nullptr) { |
| mvStreamImg[STREAM_IMG_IN_OPAQUE] = rParams.pInImage_opaque; |
| } |
| if (rParams.pOutImage_opaque != nullptr) { |
| mvStreamImg[STREAM_IMG_OUT_OPAQUE] = rParams.pOutImage_opaque; |
| } |
| |
| for (size_t i = 0; i < rParams.pvOutImage_full.size(); i++) { |
| if (rParams.pvOutImage_full[i] != nullptr) { // pick the first item |
| mvStreamImg[STREAM_IMG_OUT_FULL] = rParams.pvOutImage_full[i]; |
| break; |
| } |
| } |
| |
| if (rParams.pOutImage_resizer != nullptr) { |
| mvStreamImg[STREAM_IMG_OUT_RESIZE] = rParams.pOutImage_resizer; |
| } |
| |
| if (rParams.pOutImage_lcso != nullptr) { |
| mvStreamImg[STREAM_IMG_OUT_LCS] = rParams.pOutImage_lcso; |
| mEnableLCSO = MTRUE; |
| } |
| |
| // |
| mpStreamPool_full = rParams.pStreamPool_full; |
| mpStreamPool_resizer = rParams.pStreamPool_resizer; |
| mpStreamPool_lcso = rParams.pStreamPool_lcso; |
| // |
| #if 0 |
| #warning "[FIXME] force to change p1 not use pool" |
| { |
| MUINT8 no_pool = |
| ::property_get_int32("vendor.debug.camera.p1nopool", 0); |
| if (no_pool > 0) { |
| mpStreamPool_full = NULL; |
| mpStreamPool_resizer = NULL; |
| mpStreamPool_lcso = NULL; |
| mpStreamPool_rsso = NULL; |
| } |
| MY_LOGI("debug.camera.p1nopool = %d", no_pool); |
| } |
| #endif |
| // |
| { mspSyncHelper = rParams.pSyncHelper; } |
| // |
| { |
| if (mspResConCtrl != nullptr) { |
| P1NODE_RES_CON_RETURN(mspResConCtrl, mResConClient); |
| mspResConCtrl = nullptr; |
| } |
| mspResConCtrl = rParams.pResourceConcurrency; |
| if (mspResConCtrl != nullptr) { |
| mResConClient = IResourceConcurrency::CLIENT_HANDLER_NULL; |
| mIsResConGot = MFALSE; |
| } |
| } |
| // |
| mBurstNum = MAX(rParams.burstNum, 1); |
| #if (ENABLE_CHECK_CONFIG_COMMON_PORPERTY || (0)) // for SMVR IT |
| #warning "[FIXME] force to change p1 burst number" |
| { |
| MUINT8 burst_num = ::property_get_int32("vendor.debug.camera.p1burst", 0); |
| if (burst_num > 0) { |
| mBurstNum = burst_num; |
| } |
| MY_LOGI("debug.camera.p1burst = %d - BurstNum = %d", burst_num, |
| mBurstNum); |
| } |
| #endif |
| // |
| mReceiveMode = rParams.receiveMode; |
| #if (ENABLE_CHECK_CONFIG_COMMON_PORPERTY || (0)) // receive mode IT |
| #warning "[FIXME] force to change p1 receive mode" |
| { |
| MUINT8 rev_mode = ::property_get_int32("vendor.debug.camera.p1rev", 0); |
| if (rev_mode > 0) { |
| mReceiveMode = (REV_MODE)rev_mode; |
| } |
| MY_LOGI("debug.camera.p1rev = %d - RevMode=%d BurstNum=%d", rev_mode, |
| mReceiveMode, mBurstNum); |
| } |
| #endif |
| // |
| // #warning "force to change standby mode" |
| { |
| MINT8 standby_mode = |
| ::property_get_int32("vendor.debug.camera.p1standbymode", 0); |
| if (standby_mode > 0) { |
| mForceStandbyMode = standby_mode; |
| MY_LOGI("debug.camera.standbymode = %d - ForceStandbyMode = %d", |
| standby_mode, mForceStandbyMode); |
| } |
| } |
| // |
| std::string meta_str(""); |
| mCfgAppMeta.clear(); |
| if (rParams.cfgAppMeta.count() > 0) { |
| mCfgAppMeta = rParams.cfgAppMeta; |
| if (1 <= mLogLevelI) { |
| base::StringAppendF(&meta_str, " -- ConfigParams.cfgAppMeta[%d] ", |
| rParams.cfgAppMeta.count()); |
| for (MUINT32 i = 0; i < rParams.cfgAppMeta.count(); i++) { |
| generateMetaInfoStr(rParams.cfgAppMeta.entryAt(i), &meta_str); |
| } |
| } |
| } |
| mCfgHalMeta.clear(); |
| if (rParams.cfgHalMeta.count() > 0) { |
| mCfgHalMeta = rParams.cfgHalMeta; |
| if (1 <= mLogLevelI) { |
| base::StringAppendF(&meta_str, " -- ConfigParams.cfgHalMeta[%d] ", |
| rParams.cfgHalMeta.count()); |
| for (MUINT32 i = 0; i < rParams.cfgHalMeta.count(); i++) { |
| generateMetaInfoStr(rParams.cfgHalMeta.entryAt(i), &meta_str); |
| } |
| } |
| } |
| if (!meta_str.empty()) { |
| MY_LOGI("%s", meta_str.c_str()); |
| } |
| // |
| mSensorParams = rParams.sensorParams; |
| // |
| mRawProcessed = rParams.rawProcessed; |
| mRawSetDefType = rParams.rawDefType; |
| // |
| mTgNum = rParams.tgNum; |
| // |
| mPipeMode = rParams.pipeMode; |
| // |
| mPipeBit = rParams.pipeBit; |
| // |
| mResizeQuality = rParams.resizeQuality; |
| // |
| mDisableHLR = rParams.disableHLR; |
| // |
| mDisableFrontalBinning = rParams.disableFrontalBinning; |
| // |
| mDisableDynamicTwin = rParams.disableDynamicTwin; |
| // |
| mEnableUniForcedOn = rParams.enableUNI; |
| // |
| if (IS_LMV(mpConnectLMV)) { |
| mEnableEISO = rParams.enableEIS; |
| mForceSetEIS = rParams.forceSetEIS; |
| mPackedEisInfo = rParams.packedEisInfo; |
| } |
| mEnableCaptureFlow = rParams.enableCaptureFlow; |
| mEnableFrameSync = rParams.enableFrameSync; |
| if (EN_START_CAP) { // disable - acquire init buffer from pool |
| mpStreamPool_full = nullptr; |
| mpStreamPool_resizer = nullptr; |
| } |
| // |
| { |
| mInitReqSet = rParams.initRequest; |
| #if (ENABLE_CHECK_CONFIG_COMMON_PORPERTY) // init request set IT |
| #warning "[FIXME] force to set init request" |
| { |
| MUINT8 init_req = ::property_get_int32("vendor.debug.camera.p1init", 0); |
| if (init_req > 0) { |
| mInitReqSet = init_req; |
| } |
| MY_LOGI("debug.camera.p1init = %d - mInitReq=%d BurstNum=%d", init_req, |
| mInitReqSet, mBurstNum); |
| } |
| #endif |
| if (EN_INIT_REQ_CFG && mInitReqSet <= P1NODE_DEF_SHUTTER_DELAY) { |
| MY_LOGE("INVALID init request value (%d)", mInitReqSet); |
| pthread_rwlock_unlock(&mConfigRWLock); |
| return INVALID_OPERATION; |
| } |
| mInitReqNum = |
| mInitReqSet * |
| mBurstNum; // the InitReq setting will re-assign as re-configure |
| mInitReqCnt = 0; |
| mInitReqOff = MFALSE; |
| if (EN_INIT_REQ_CFG) { |
| MY_LOGI("InitReq Set:%d Num:%d Cnt:%d Off:%d", mInitReqSet, mInitReqNum, |
| mInitReqCnt, mInitReqOff); |
| } |
| } |
| // |
| if (IS_BURST_ON) { |
| mDepthNum = 2; |
| } else if (isRevMode(REV_MODE_CONSERVATIVE)) { |
| mDepthNum = 2; |
| } else { |
| mDepthNum = 1; |
| } |
| // |
| { |
| if (((EN_BURST_MODE) && |
| (EN_INIT_REQ_CFG || EN_START_CAP || EN_REPROCESSING)) || |
| (EN_INIT_REQ_CFG && EN_START_CAP)) { |
| MY_LOGE( |
| "[Check_Config_Conflict] P1Node::ConfigParams:: " |
| "burstNum(%d) enableCaptureFlow(%d) initRequest(%d) " |
| "pInImage_opaque[%#" PRIx64 |
| "] " |
| "pInImage_yuv[%#" PRIx64 "] ", |
| rParams.burstNum, rParams.enableCaptureFlow, rParams.initRequest, |
| ((mvStreamImg[STREAM_IMG_IN_OPAQUE] == nullptr) |
| ? (StreamId_T)(-1) |
| : mvStreamImg[STREAM_IMG_IN_OPAQUE]->getStreamId()), |
| ((mvStreamImg[STREAM_IMG_IN_YUV] == nullptr) |
| ? (StreamId_T)(-1) |
| : mvStreamImg[STREAM_IMG_IN_YUV]->getStreamId())); |
| pthread_rwlock_unlock(&mConfigRWLock); |
| return INVALID_OPERATION; |
| } |
| } |
| pthread_rwlock_unlock(&mConfigRWLock); |
| } |
| // |
| if (mvStreamImg[STREAM_IMG_OUT_OPAQUE] != nullptr) { |
| if (mvStreamImg[STREAM_IMG_OUT_FULL] != nullptr) { |
| mRawFormat = mvStreamImg[STREAM_IMG_OUT_FULL]->getImgFormat(); |
| mRawStride = |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getBufPlanes()[0].rowStrideInBytes; |
| mRawLength = |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getBufPlanes()[0].sizeInBytes; |
| } else { |
| mRawFormat = P1_IMGO_DEF_FMT; |
| NormalPipe_QueryInfo queryRst; |
| getNormalPipeModule()->query(PORT_IMGO.index, ENPipeQueryCmd_STRIDE_BYTE, |
| (EImageFormat)mRawFormat, |
| mSensorParams.size.w, &queryRst); |
| mRawStride = queryRst.stride_byte; |
| mRawLength = mRawStride * mSensorParams.size.h; |
| } |
| } |
| // |
| { |
| std::shared_ptr<IMetadataProvider> pMetadataProvider = |
| NSMetadataProviderManager::valueFor(getOpenId()); |
| if (!pMetadataProvider.get()) { |
| MY_LOGE(" ! pMetadataProvider.get() "); |
| return DEAD_OBJECT; |
| } |
| IMetadata static_meta = pMetadataProvider->getMtkStaticCharacteristics(); |
| if (tryGetMetadata<MRect>(&static_meta, MTK_SENSOR_INFO_ACTIVE_ARRAY_REGION, |
| &mActiveArray)) { |
| MY_LOGD_IF(mLogLevel > 1, "active array(%d, %d, %dx%d)", mActiveArray.p.x, |
| mActiveArray.p.y, mActiveArray.s.w, mActiveArray.s.h); |
| } else { |
| MY_LOGE("no static info: MTK_SENSOR_INFO_ACTIVE_ARRAY_REGION"); |
| #if (P1NODE_USING_MTK_LDVT > 0) |
| mActiveArray = MRect(mSensorParams.size.w, mSensorParams.size.h); |
| MY_LOGI("set sensor size to active array(%d, %d, %dx%d)", |
| mActiveArray.p.x, mActiveArray.p.y, mActiveArray.s.w, |
| mActiveArray.s.h); |
| #else |
| return UNKNOWN_ERROR; |
| #endif |
| } |
| } |
| // |
| if (mvStreamImg[STREAM_IMG_OUT_FULL] != nullptr) { |
| if (mvStreamImg[STREAM_IMG_OUT_FULL]->getImgSize() != mSensorParams.size) { |
| MY_LOGE( |
| "[Check_Config_Conflict] IMGO_Stream.ImgSize(%dx%d) != " |
| "SensorParam.Size(%d,%d) - P1Node::ConfigParams:: " |
| "IMGO_StreamID:%#" PRIx64 |
| "_ImgFormat[0x%x]-ImgSize(%dx%d) " |
| "SensorParam_mode(%d)_fps(%d)_pixelMode(%d)_vhdrMode(%d)_" |
| "size(%dx%d)", |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getImgSize().w, |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getImgSize().h, |
| mSensorParams.size.w, mSensorParams.size.h, |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getStreamId(), |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getImgFormat(), |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getImgSize().w, |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getImgSize().h, mSensorParams.mode, |
| mSensorParams.fps, mSensorParams.pixelMode, mSensorParams.vhdrMode, |
| mSensorParams.size.w, mSensorParams.size.h); |
| return INVALID_OPERATION; |
| } |
| } |
| // |
| { |
| MERROR res = checkConstraint(); |
| if (res != OK) { |
| return res; |
| } |
| } |
| // |
| mLogInfo.config(getOpenId(), mLogLevel, mLogLevelI, mBurstNum); |
| mLogInfo.setActive(MFALSE); |
| // |
| { |
| MBOOL deliver_mgr_send = MTRUE; |
| |
| MY_LOGD("USE DeliverMgr Thread Loop : %d", deliver_mgr_send); |
| if (deliver_mgr_send) { |
| if (mpDeliverMgr != nullptr) { |
| mpDeliverMgr->config(); |
| if (NO_ERROR == mpDeliverMgr->run()) { |
| MY_LOGD("RUN DeliverMgr Thread OK"); |
| mpDeliverMgr->runningSet(MTRUE); |
| } else { |
| MY_LOGE("RUN DeliverMgr Thread FAIL"); |
| return BAD_VALUE; |
| } |
| } |
| } |
| } |
| // |
| if (mpTaskCtrl != nullptr) { |
| mpTaskCtrl->config(); |
| } |
| if (mpTaskCollector != nullptr) { |
| mpTaskCollector->config(); |
| } |
| if (mpRegisterNotify != nullptr) { |
| mpRegisterNotify->config(); |
| } |
| // |
| { |
| MUINT32 queReserve = mBurstNum * P1NODE_DEF_QUEUE_DEPTH; |
| { |
| std::lock_guard<std::mutex> _ll(mDropQueueLock); |
| mDropQueue.clear(); |
| mDropQueue.reserve(queReserve); |
| } |
| { |
| std::lock_guard<std::mutex> _ll(mRequestQueueLock); |
| mRequestQueue.clear(); |
| mRequestQueue.reserve(queReserve); |
| } |
| { |
| std::lock_guard<std::mutex> _ll(mProcessingQueueLock); |
| mProcessingQueue.clear(); |
| mProcessingQueue.reserve(queReserve); |
| } |
| } |
| |
| #if (IS_P1_LOGI) |
| { |
| std::string strInfo(""); |
| strInfo += base::StringPrintf("Cam::%d ", getOpenId()); |
| // |
| strInfo += base::StringPrintf( |
| "Param[" |
| "N:m%d,p%d,q%d,t%d,b%d,i%d,r%d,w%d,v%" PRId64 |
| "_" |
| "B:p%d,b%d,t%d,h%d,u%d,e%d,l%d,v%d] ", |
| // Param-iNt/eNum |
| rParams.pipeMode /*m*/, rParams.pipeBit /*p*/, |
| rParams.resizeQuality /*q*/, rParams.tgNum /*t*/, |
| rParams.burstNum /*b*/, rParams.initRequest /*i*/, |
| rParams.receiveMode /*r*/, rParams.rawDefType /*w*/, |
| rParams.packedEisInfo /*v*/ /*EisInfo::getMode(mPackedEisInfo)*/, |
| // Param-Bool |
| rParams.rawProcessed /*p*/, rParams.disableFrontalBinning /*b*/, |
| rParams.disableDynamicTwin /*t*/, rParams.disableHLR /*h*/, |
| rParams.enableUNI /*u*/, rParams.enableEIS /*e*/, |
| rParams.enableLCS /*l*/, rParams.forceSetEIS /*v*/); |
| // |
| strInfo += base::StringPrintf( |
| "S(%d,%d,%d,%d,x%x,%dx%d) ", mSensorParams.mode, mSensorParams.fps, |
| mSensorParams.pixelMode, mSensorParams.vhdrMode, mSensorFormatOrder, |
| mSensorParams.size.w, mSensorParams.size.h); |
| strInfo += base::StringPrintf("R(0x%x-%d-%d,%d-%d-%d,%d-0x%x) ", mRawFormat, |
| mRawStride, mRawLength, mRawPostProcSupport, |
| mRawProcessed, mRawSetDefType, mRawDefType, |
| mRawOption); |
| strInfo += |
| base::StringPrintf("D(b%d,t%d,h%d) ", mDisableFrontalBinning /*b*/, |
| mDisableDynamicTwin /*t*/, mDisableHLR /*h*/); |
| strInfo += |
| base::StringPrintf("E(l%d,r%d,u%d,c%d,f%d) ", mEnableLCSO /*l*/, |
| mEnableRSSO /*r*/, mEnableUniForcedOn /*u*/, |
| mEnableCaptureFlow /*c*/, mEnableFrameSync /*f*/); |
| strInfo += base::StringPrintf( |
| "M(m0x%x,p0x%x,q%d,t%d,b%d,d%d,r%d,i%d", mPipeMode /*m*/, |
| mPipeBit /*p*/, mResizeQuality /*q*/, mTgNum /*t*/, mBurstNum /*b*/, |
| mDepthNum /*d*/, mReceiveMode /*r*/, mInitReqSet /*i*/ |
| /*v*/ /*EisInfo::getMode(mPackedEisInfo)*/); |
| strInfo += base::StringPrintf("Dm(%d) ", mpDeliverMgr->runningGet()); |
| strInfo += base::StringPrintf("Rc(%p) ", mspResConCtrl.get()); |
| strInfo += base::StringPrintf("Sh(%p) ", mspSyncHelper.get()); |
| strInfo += base::StringPrintf( |
| "Pool(IMG%p,RRZ%p,LCS%p,RSS%p) ", |
| (mpStreamPool_full != NULL) ? (mpStreamPool_full.get()) : (NULL), |
| (mpStreamPool_resizer != NULL) ? (mpStreamPool_resizer.get()) : (NULL), |
| (mpStreamPool_lcso != NULL) ? (mpStreamPool_lcso.get()) : (NULL), |
| (mpStreamPool_rsso != NULL) ? (mpStreamPool_rsso.get()) : (NULL)); |
| strInfo += base::StringPrintf( |
| "Meta%s_%d:%#" PRIx64 " Meta%s_%d:%#" PRIx64 |
| " " |
| "Meta%s_%d:%#" PRIx64 " Meta%s_%d:%#" PRIx64 " ", |
| maStreamMetaName[STREAM_META_IN_APP], STREAM_META_IN_APP, |
| (mvStreamMeta[STREAM_META_IN_APP] == nullptr) |
| ? (StreamId_T)(-1) |
| : mvStreamMeta[STREAM_META_IN_APP]->getStreamId(), |
| maStreamMetaName[STREAM_META_IN_HAL], STREAM_META_IN_HAL, |
| (mvStreamMeta[STREAM_META_IN_HAL] == nullptr) |
| ? (StreamId_T)(-1) |
| : mvStreamMeta[STREAM_META_IN_HAL]->getStreamId(), |
| maStreamMetaName[STREAM_META_OUT_APP], STREAM_META_OUT_APP, |
| (mvStreamMeta[STREAM_META_OUT_APP] == nullptr) |
| ? (StreamId_T)(-1) |
| : mvStreamMeta[STREAM_META_OUT_APP]->getStreamId(), |
| maStreamMetaName[STREAM_META_OUT_HAL], STREAM_META_OUT_HAL, |
| (mvStreamMeta[STREAM_META_OUT_HAL] == nullptr) |
| ? (StreamId_T)(-1) |
| : mvStreamMeta[STREAM_META_OUT_HAL]->getStreamId()); |
| // |
| for (int i = STREAM_ITEM_START; i < STREAM_IMG_NUM; i++) { |
| if (mvStreamImg[i] != nullptr) { |
| strInfo += base::StringPrintf( |
| "Img%s_%d:%#" PRIx64 "(%dx%d)[0x%x] ", (maStreamImgName[i]), i, |
| mvStreamImg[i]->getStreamId(), mvStreamImg[i]->getImgSize().w, |
| mvStreamImg[i]->getImgSize().h, mvStreamImg[i]->getImgFormat()); |
| } |
| } |
| // |
| strInfo += base::StringPrintf( |
| "Meta(APP:%d=%d,HAL:%d=%d) ", rParams.cfgAppMeta.count(), |
| mCfgAppMeta.count(), rParams.cfgHalMeta.count(), mCfgHalMeta.count()); |
| // |
| |
| if (mvStreamImg[STREAM_IMG_OUT_RESIZE] != nullptr) { |
| strInfo += base::StringPrintf( |
| "RR(%d) ", getResizeMaxRatio( |
| mvStreamImg[STREAM_IMG_OUT_RESIZE]->getImgFormat())); |
| } |
| // |
| strInfo += base::StringPrintf("AA(%d,%d-%dx%d) ", mActiveArray.p.x, |
| mActiveArray.p.y, mActiveArray.s.w, |
| mActiveArray.s.h); |
| // |
| MY_LOGI("%s", strInfo.c_str()); |
| } |
| #endif |
| |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::checkConstraint() { |
| auto pModule = getNormalPipeModule(); |
| if (!pModule) { |
| MY_LOGE("getNormalPipeModule() fail"); |
| return UNKNOWN_ERROR; |
| } |
| // check raw type |
| { mRawPostProcSupport = isPostProcRawSupported(); } |
| if (mPipeMode == PIPE_MODE_NORMAL_SV) { // only support pure raw |
| mRawDefType = EPipe_PURE_RAW; |
| mRawOption = (1 << EPipe_PURE_RAW); |
| if (mRawSetDefType == RAW_DEF_TYPE_PROCESSED_RAW) { |
| MY_LOGE( |
| "INVALID Raw-Default-Type option, " |
| "P1Node::ConfigParams::PipeMode(%d) is PIPE_MODE_NORMAL_SV - " |
| "it will reject the P1Node::ConfigParams::rawDefType(%d) " |
| "A.K.A. RAW_DEF_TYPE_PROCESSED_RAW", |
| mPipeMode, mRawSetDefType); |
| return INVALID_OPERATION; |
| } |
| if (mRawProcessed == MTRUE) { |
| MY_LOGE( |
| "INVALID Raw-Processed option, " |
| "P1Node::ConfigParams::PipeMode(%d) is PIPE_MODE_NORMAL_SV - " |
| "it will reject the P1Node::ConfigParams::rawProcessed(%d) ", |
| mPipeMode, mRawProcessed); |
| return INVALID_OPERATION; |
| } |
| } else if (mRawPostProcSupport) { |
| mRawDefType = EPipe_PURE_RAW; |
| mRawOption = (1 << EPipe_PURE_RAW); |
| if (mRawProcessed == MTRUE) { |
| // DualPD, raw type will be selected by driver |
| mRawDefType = EPipe_PROCESSED_RAW; |
| mRawOption |= (1 << EPipe_PROCESSED_RAW); |
| } |
| if (mRawSetDefType == RAW_DEF_TYPE_AUTO) { |
| // by previous decision |
| } else if (mRawSetDefType == RAW_DEF_TYPE_PURE_RAW) { |
| mRawDefType = EPipe_PURE_RAW; // accepted |
| } else if (mRawSetDefType == RAW_DEF_TYPE_PROCESSED_RAW) { |
| if (mRawProcessed == MTRUE) { |
| mRawDefType = EPipe_PROCESSED_RAW; // accepted |
| } else { |
| MY_LOGE( |
| "INVALID Raw-Default-Type option, " |
| "P1Node::ConfigParams::rawProcessed(%d) not enabled - " |
| "it will reject the P1Node::ConfigParams::rawDefType(%d) " |
| "A.K.A. RAW_DEF_TYPE_PROCESSED_RAW", |
| mRawProcessed, mRawSetDefType); |
| return INVALID_OPERATION; |
| } |
| } else { |
| MY_LOGE( |
| "INVALID Raw-Default-Type option, " |
| "P1Node::ConfigParams::rawProcessed(%d) - " |
| "P1Node::ConfigParams::rawDefType(%d) " |
| "UNKNOWN type", |
| mRawProcessed, mRawSetDefType); |
| return INVALID_OPERATION; |
| } |
| } else { // i.e. the platform without HW PostProc raw support |
| // ignore mRawProcessed value |
| mRawOption = (1 << EPipe_PURE_RAW) | (1 << EPipe_PROCESSED_RAW); |
| if (mRawSetDefType == RAW_DEF_TYPE_AUTO || |
| mRawSetDefType == RAW_DEF_TYPE_PROCESSED_RAW) { |
| mRawDefType = EPipe_PROCESSED_RAW; // accepted |
| } else if (mRawSetDefType == RAW_DEF_TYPE_PURE_RAW) { |
| mRawDefType = EPipe_PURE_RAW; |
| MY_LOGW( |
| "WARNING Raw-Default-Type option, " |
| "use default-pure-raw without post-proc-raw-support - " |
| "P1Node::ConfigParams::rawDefType(%d)", |
| mRawSetDefType); |
| // return INVALID_OPERATION; |
| } else { |
| MY_LOGE( |
| "INVALID Raw-Default-Type option, " |
| "P1Node::ConfigParams::rawDefType(%d) " |
| "UNKNOWN type", |
| mRawSetDefType); |
| return INVALID_OPERATION; |
| } |
| } |
| // |
| // check Burst Mode |
| if (mBurstNum > 1) { |
| MBOOL ret = MFALSE; |
| sCAM_QUERY_BURST_NUM res; |
| res.QueryOutput = 0x0; |
| ret = pModule->query(ENPipeQueryCmd_BURST_NUM, (MUINTPTR)(&res)); |
| if (!ret) { |
| MY_LOGE("[Cam::%d] Cannot query ENPipeQueryCmd_BURST_NUM", getOpenId()); |
| #if USING_DRV_QUERY_CAPABILITY_EXP_SKIP |
| MY_LOGW("USING_DRV_QUERY_CAPABILITY_EXP_SKIP go-on"); |
| #else |
| return BAD_VALUE; |
| #endif |
| } else if ((res.QueryOutput & (0x1 << mBurstNum)) == 0x0) { |
| MY_LOGE( |
| "[Cam::%d] ENPipeQueryCmd_BURST_NUM - support (0x%X) ," |
| " but BurstNum set as (0x%X)", |
| getOpenId(), res.QueryOutput, mBurstNum); |
| #if USING_DRV_QUERY_CAPABILITY_EXP_SKIP |
| MY_LOGW("USING_DRV_QUERY_CAPABILITY_EXP_SKIP go-on"); |
| #else |
| return INVALID_OPERATION; |
| #endif |
| } |
| } |
| // |
| // check Raw Pattern |
| mCfg.mPattern = eCAM_NORMAL; |
| { |
| if (mSensorParams.vhdrMode == SENSOR_VHDR_MODE_ZVHDR) { |
| // ZVHDR Mode, pass ZVHDR relative enum to P1 driver |
| mCfg.mPattern = (eCAM_ZVHDR); |
| } else if (mSensorParams.vhdrMode == SENSOR_VHDR_MODE_IVHDR) { |
| // IVHDR Mode, pass IVHDR relative enum to P1 driver |
| mCfg.mPattern = (eCAM_IVHDR); |
| } else { |
| mCfg.mPattern = (eCAM_NORMAL); // EPipe_Normal |
| } |
| } |
| if (mCfg.mPattern != eCAM_NORMAL) { |
| MBOOL ret = MFALSE; |
| sCAM_QUERY_SUPPORT_PATTERN res; |
| res.QueryOutput = 0x0; |
| ret = pModule->query(ENPipeQueryCmd_SUPPORT_PATTERN, (MUINTPTR)(&res)); |
| if (!ret) { |
| MY_LOGE("[Cam::%d] Cannot query ENPipeQueryCmd_SUPPORT_PATTERN", |
| getOpenId()); |
| #if USING_DRV_QUERY_CAPABILITY_EXP_SKIP |
| MY_LOGW("USING_DRV_QUERY_CAPABILITY_EXP_SKIP go-on"); |
| #else |
| return BAD_VALUE; |
| #endif |
| } else if ((res.QueryOutput & (0x1 << mCfg.mPattern)) == 0x0) { |
| MY_LOGE( |
| "[Cam::%d] ENPipeQueryCmd_IQ_LEVEL - support (0x%X) ," |
| " but Pattern set as (0x%X) - by " |
| " VhdrMode(%d)", |
| getOpenId(), res.QueryOutput, mCfg.mPattern, mSensorParams.vhdrMode); |
| #if USING_DRV_QUERY_CAPABILITY_EXP_SKIP |
| MY_LOGW("USING_DRV_QUERY_CAPABILITY_EXP_SKIP go-on"); |
| #else |
| return INVALID_OPERATION; |
| #endif |
| } |
| } |
| // |
| // check IQ Level |
| mCfg.mQualityLv = eCamIQ_MAX; |
| { |
| switch (mResizeQuality) { |
| case RESIZE_QUALITY_H: |
| mCfg.mQualityLv = eCamIQ_H; |
| break; |
| case RESIZE_QUALITY_L: |
| mCfg.mQualityLv = eCamIQ_L; |
| break; |
| default: |
| break; |
| } |
| } |
| if (mCfg.mQualityLv != eCamIQ_MAX) { |
| MBOOL ret = MFALSE; |
| sCAM_QUERY_IQ_LEVEL res; |
| res.QueryOutput = MFALSE; |
| ret = pModule->query(ENPipeQueryCmd_IQ_LEVEL, (MUINTPTR)(&res)); |
| if (!ret) { |
| MY_LOGE("[Cam::%d] Cannot query ENPipeQueryCmd_IQ_LEVEL", getOpenId()); |
| #if USING_DRV_QUERY_CAPABILITY_EXP_SKIP |
| MY_LOGW("USING_DRV_QUERY_CAPABILITY_EXP_SKIP go-on"); |
| #else |
| return BAD_VALUE; |
| #endif |
| } else if (res.QueryOutput == MFALSE) { |
| MY_LOGE( |
| "[Cam::%d] ENPipeQueryCmd_IQ_LEVEL - not support ," |
| " but Quality-Level set as (%d)", |
| getOpenId(), mCfg.mQualityLv); |
| #if USING_DRV_QUERY_CAPABILITY_EXP_SKIP |
| MY_LOGW("USING_DRV_QUERY_CAPABILITY_EXP_SKIP go-on"); |
| #else |
| return INVALID_OPERATION; |
| #endif |
| } |
| } |
| // |
| // check Dynamic Twin |
| mCfg.mSupportDynamicTwin = MFALSE; |
| { |
| MBOOL ret = MFALSE; |
| sCAM_QUERY_D_Twin res; |
| res.QueryOutput = MFALSE; |
| ret = pModule->query(ENPipeQueryCmd_D_Twin, (MUINTPTR)(&res)); |
| if (!ret) { |
| MY_LOGE("[Cam::%d] Cannot query ENPipeQueryCmd_D_Twin", getOpenId()); |
| #if USING_DRV_QUERY_CAPABILITY_EXP_SKIP |
| MY_LOGW("USING_DRV_QUERY_CAPABILITY_EXP_SKIP go-on"); |
| #else |
| return BAD_VALUE; |
| #endif |
| } |
| mCfg.mSupportDynamicTwin = res.QueryOutput; |
| } |
| // |
| mIsLegacyStandbyMode = (mCfg.mSupportDynamicTwin) ? MFALSE : MTRUE; |
| mIsDynamicTwinEn = |
| (mCfg.mSupportDynamicTwin && (!mDisableDynamicTwin)) ? MTRUE : MFALSE; |
| // |
| // check Sensor-TG Number |
| mCfg.mSensorNum = E_1_SEN; |
| switch (mTgNum) { |
| case 0: |
| case 1: |
| mCfg.mSensorNum = E_1_SEN; |
| break; |
| case 2: |
| default: |
| mCfg.mSensorNum = E_2_SEN; |
| break; |
| } |
| // |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::config(ConfigParams const& rParams) { |
| FUNCTION_IN; |
| P1_TRACE_AUTO(SLG_B, "P1:config"); |
| |
| std::lock_guard<std::mutex> _l(mPublicLock); |
| |
| if (getActive()) { |
| MY_LOGD("active=%d", getActive()); |
| onHandleFlush(MFALSE); |
| } |
| |
| // (1) check |
| if (mpTimingCheckerMgr != nullptr) { |
| mpTimingCheckerMgr->setEnable(MTRUE); |
| } |
| // |
| MERROR err = check_config(rParams); |
| if (err != OK) { |
| MY_LOGE("Config Param - Check fail (%d)", err); |
| return err; |
| } |
| |
| // (2) configure hardware |
| if (mpConCtrl != nullptr && |
| (!EN_INIT_REQ_RUN)) { // init-request, no aid-start |
| mpConCtrl->setAidUsage(MTRUE); |
| } |
| // |
| if (mpTimingCheckerMgr != nullptr) { |
| mpTimingCheckerMgr->waitReady(); |
| } |
| // |
| mpTaskCtrl->reset(); |
| // |
| err = hardwareOps_start(); |
| if ((!(EN_START_CAP || EN_INIT_REQ_RUN)) || (err != OK)) { |
| if (mpConCtrl != nullptr && mpConCtrl->getAidUsage() == MTRUE) { |
| mpConCtrl->cleanAidStage(); |
| } |
| if (mpTimingCheckerMgr != nullptr) { |
| mpTimingCheckerMgr->setEnable(MFALSE); |
| } |
| } |
| if (err != OK) { |
| MY_LOGE("Config Param - HW start fail (%d)", err); |
| return err; |
| } |
| |
| FUNCTION_OUT; |
| |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::fetchJob(P1QueJob* rOutJob) { |
| if (CC_UNLIKELY(mpTaskCtrl == nullptr || mpTaskCollector == nullptr)) { |
| return BAD_VALUE; |
| } |
| rOutJob->clear(); |
| MINT cnt = 0; |
| mpTaskCtrl->sessionLock(); |
| cnt = mpTaskCollector->requireJob(rOutJob); |
| mTagList.set(cnt); |
| if (rOutJob->empty()) { |
| MY_LOGI("using-dummy-request"); |
| if (2 <= mLogLevelI) { |
| mpTaskCollector->dumpRoll(); |
| } |
| // |
| P1TaskCollector dummyCollector(mpTaskCtrl); |
| for (int i = 0; i < mBurstNum; i++) { |
| P1QueAct newAct; |
| dummyCollector.enrollAct(&newAct); |
| createAction(&newAct, nullptr, REQ_TYPE_DUMMY); |
| dummyCollector.verifyAct(&newAct); |
| } |
| dummyCollector.requireJob(rOutJob); |
| } |
| mpTaskCtrl->sessionUnLock(); |
| if (!rOutJob->ready()) { |
| MY_LOGE("job-not-ready"); |
| mpTaskCtrl->dumpActPool(); |
| return BAD_VALUE; |
| } |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::setRequest(MBOOL initial) { |
| FUNCTION_IN; |
| // |
| std::lock_guard<std::mutex> _ll(mFrameSetLock); |
| if (CC_UNLIKELY(!initial && !mFrameSetAlready)) { |
| MY_LOGI("frame set not init complete"); |
| return; |
| } |
| if (CC_UNLIKELY(!getActive())) { |
| MY_LOGI("not-active-return"); |
| return; |
| } |
| // |
| P1QueJob job(mBurstNum); |
| // |
| { |
| if (OK != fetchJob(&job)) { |
| MY_LOGE("job-fetch-fail"); |
| return; |
| } |
| if (mpHwStateCtrl != nullptr && mpHwStateCtrl->isLegacyStandby() && |
| mpHwStateCtrl->checkReceiveRestreaming()) { |
| P1Act pAct = GET_ACT_PTR(pAct, job.edit(0), RET_VOID); |
| if (pAct->ctrlSensorStatus == SENSOR_STATUS_CTRL_STREAMING) { |
| mpHwStateCtrl->checkRestreamingNum(pAct->getNum()); |
| } |
| } |
| } |
| // |
| if (!initial) { |
| beckonRequest(); |
| } |
| // |
| if (IS_BURST_OFF && // exclude burst mode |
| (job.size() >= 1)) { // check control callback |
| attemptCtrlSetting(&(job.edit(0))); |
| } |
| // |
| #if USING_CTRL_3A_LIST |
| List<NS3Av3::MetaSet_T> ctrlList; |
| generateCtrlList(&ctrlList, &job); |
| MY_LOGD("CtrlList[%zu]", ctrlList.size()); |
| #else |
| std::vector<NS3Av3::MetaSet_T*> ctrlQueue; |
| ctrlQueue.clear(); |
| ctrlQueue.reserve(job.size()); |
| generateCtrlQueue(&ctrlQueue, &job); |
| MY_LOGD("CtrlQueue[%zu]", ctrlQueue.size()); |
| #endif |
| // |
| mLastSetNum = job.getLastNum(); |
| mTagSet.set(mLastSetNum); |
| { |
| std::lock_guard<std::mutex> _l(mRequestQueueLock); |
| mRequestQueue.push_back(job); |
| } |
| P1QueAct* qAct = (job.ready()) ? (job.getLastAct()) : (nullptr); |
| if (qAct == nullptr) { |
| MY_LOGW("job-not-ready [%zu] < [%d]", job.size(), job.getMax()); |
| return; |
| } |
| P1Act pAct = GET_ACT_PTR(pAct, (*qAct), RET_VOID); |
| #if SUPPORT_3A |
| if (mp3A) { |
| MINT32 p_key = qAct->id(); |
| MINT32 m_num = pAct->magicNum; |
| MINT32 f_num = pAct->frmNum; |
| MINT32 r_num = pAct->reqNum; |
| if (initial) { |
| mLogInfo.setMemo(LogInfo::CP_START_SET_BGN, LogInfo::START_SET_GENERAL, |
| m_num); |
| } |
| mLogInfo.setMemo(LogInfo::CP_SET_BGN, p_key, m_num, f_num, r_num); |
| P1_TRACE_F_BEGIN(SLG_I, "P1:3A-set|Pkey:%d Mnum:%d Fnum:%d Rnum:%d", p_key, |
| m_num, f_num, r_num); |
| MY_LOGD("mp3A->set[%d](%d) +++", p_key, m_num); |
| #if USING_CTRL_3A_LIST |
| mp3A->set(ctrlList); |
| #else |
| mp3A->set(ctrlQueue); |
| #endif |
| MY_LOGD("mp3A->set[%d](%d) ---", p_key, m_num); |
| P1_TRACE_C_END(SLG_I); // "P1:3A-set" |
| mLogInfo.setMemo(LogInfo::CP_SET_END, p_key, m_num, f_num, r_num); |
| if (initial) { |
| mLogInfo.setMemo(LogInfo::CP_START_SET_END, LogInfo::START_SET_GENERAL, |
| m_num); |
| } |
| mFrameSetAlready = MTRUE; |
| } |
| if (1 <= mLogLevelI) { |
| P1_TRACE_F_BEGIN(SLG_PFL, |
| "P1::SET_LOG|Mnum:%d SofIdx:%d Fnum:%d " |
| "Rnum:%d FlushSet:0x%x", |
| pAct->magicNum, pAct->sofIdx, pAct->frmNum, pAct->reqNum, |
| pAct->flushSet); |
| std::string str(""); |
| MINT32 num = 0; |
| size_t idx = 0; |
| #if USING_CTRL_3A_LIST |
| size_t size = ctrlList.size(); |
| List<NS3Av3::MetaSet_T>::iterator it = ctrlList.begin(); |
| for (; it != ctrlList.end(); it++) { |
| num = it->MagicNum; |
| if ((idx > 0) && (idx % mBurstNum == 0)) { |
| str += base::StringPrintf(", "); |
| } |
| str += base::StringPrintf("%d ", num); |
| idx++; |
| } |
| #else |
| size_t size = ctrlQueue.size(); |
| std::vector<NS3Av3::MetaSet_T*>::iterator it = ctrlQueue.begin(); |
| for (; it != ctrlQueue.end(); it++) { |
| num = ((*it) != nullptr) ? ((*it)->MagicNum) : (0); |
| str += base::StringPrintf("%d ", num); |
| idx++; |
| } |
| #endif |
| P1_LOGI(1, "[P1::SET]" P1INFO_ACT_STR " Num[%d] Ctrl[%zu]=[ %s]", |
| P1INFO_ACT_VAR(*pAct), num, size, str.c_str()); |
| P1_TRACE_C_END(SLG_PFL); // "P1::SET_LOG" |
| } |
| #endif |
| FUNCTION_OUT; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::acceptRequest(std::shared_ptr<IPipelineFrame> pFrame, |
| MUINT32* rRevResult) { |
| FUNCTION_IN; |
| *rRevResult = (MUINT32)REQ_REV_RES_ACCEPT_AVAILABLE; |
| #if (USING_DRV_IO_PIPE_EVENT) |
| { |
| pthread_rwlock_rdlock(&mIoPipeEvtStateLock); |
| if (mIoPipeEvtState != IO_PIPE_EVT_STATE_NONE) { |
| *rRevResult = (MUINT32)REQ_REV_RES_REJECT_IO_PIPE_EVT; |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| return MFALSE; |
| } |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| } |
| #endif |
| if ((!getReady()) || (!mFirstReceived)) { |
| return MTRUE; |
| } |
| // check-bypass-request |
| if (pFrame != nullptr) { |
| MBOOL isBypass = pFrame->IsReprocessFrame(); |
| if (isBypass) { |
| *rRevResult = (MUINT32)REQ_REV_RES_ACCEPT_BYPASS; |
| MY_LOGI("Num[F:%d,R:%d] - BypassFrame", P1GET_FRM_NUM(pFrame), |
| P1GET_REQ_NUM(pFrame)); |
| return MTRUE; |
| } |
| } |
| // |
| MINT cnt = 0; |
| MBOOL isAccept = checkReqCnt(&cnt); |
| MY_LOGI("Num[F:%d,R:%d] - Cnt(%d) Accept(%d)", P1GET_FRM_NUM(pFrame), |
| P1GET_REQ_NUM(pFrame), cnt, isAccept); |
| if (!isAccept) { |
| *rRevResult = (MUINT32)REQ_REV_RES_REJECT_NOT_AVAILABLE; |
| } |
| FUNCTION_OUT; |
| return isAccept; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::beckonRequest() { |
| FUNCTION_IN; |
| MINT cnt = 0; |
| if (CC_LIKELY(checkReqCnt(&cnt))) { |
| MINT32 frmNum = P1_FRM_NUM_NULL; |
| MINT32 reqNum = P1_REQ_NUM_NULL; |
| MINT32 cnt = lastFrameRequestInfoNotice(&frmNum, &reqNum, 1); |
| MBOOL exeCb = MTRUE; |
| { |
| std::lock_guard<std::mutex> _l(mPipelineCbLock); |
| std::shared_ptr<INodeCallbackToPipeline> spCb = mwpPipelineCb.lock(); |
| if (CC_LIKELY(spCb != nullptr)) { |
| MY_LOGI("Pipeline_CB (F:%d,R:%d) CbButNotQueCnt:%d +++", frmNum, reqNum, |
| cnt); |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_REQ_NOTIFY_BGN, |
| LogInfo::CP_REQ_NOTIFY_END, frmNum, reqNum, cnt); |
| INodeCallbackToPipeline::CallBackParams param; |
| param.nodeId = getNodeId(); |
| param.lastFrameNum = frmNum; |
| spCb->onCallback(param); |
| MY_LOGI("Pipeline_CB (F:%d,R:%d) CbButNotQueCnt:%d ---", frmNum, reqNum, |
| cnt); |
| } else { |
| exeCb = MFALSE; |
| } |
| } |
| if (CC_UNLIKELY(!exeCb)) { |
| cnt = lastFrameRequestInfoNotice(&frmNum, &reqNum, (-1)); // reset count |
| MY_LOGI("Pipeline_CB not exist (F:%d,R:%d) CbButNotQueCnt:%d", frmNum, |
| reqNum, cnt); |
| } |
| return MTRUE; |
| } else { |
| MY_LOGI("not-callback - cnt(%d)", cnt); |
| } |
| FUNCTION_OUT; |
| return MFALSE; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::checkReqCnt(MINT32* cnt) { |
| FUNCTION_IN; |
| if (CC_UNLIKELY(mpTaskCtrl == nullptr || mpTaskCollector == nullptr)) { |
| MY_LOGE("Task Controller or Collector not acceptable"); |
| return MFALSE; |
| } |
| // |
| MINT depth = mDepthNum; |
| MINT cnt_num = depth * mBurstNum; |
| MINT que_num = 0; |
| MBOOL isAccept = MTRUE; |
| mpTaskCtrl->sessionLock(); |
| if ((que_num = mpTaskCollector->remainder()) >= cnt_num) { |
| isAccept = MFALSE; |
| } |
| mpTaskCtrl->sessionUnLock(); |
| MY_LOGI("Que(%d) < Cnt(%d)=(%d*%d) : Accept(%d)", que_num, cnt_num, depth, |
| mBurstNum, isAccept); |
| *cnt = que_num; |
| FUNCTION_OUT; |
| return isAccept; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::setNodeCallBack(std::weak_ptr<INodeCallbackToPipeline> pCallback) { |
| std::lock_guard<std::mutex> _l(mPipelineCbLock); |
| MY_LOGI("PipelineNodeCallBack=%d", pCallback.expired()); |
| mwpPipelineCb = pCallback; |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::queue(std::shared_ptr<IPipelineFrame> pFrame) { |
| FUNCTION_IN; |
| mLogInfo.setMemo(LogInfo::CP_REQ_ARRIVE, P1GET_FRM_NUM(pFrame), |
| P1GET_REQ_NUM(pFrame)); |
| std::lock_guard<std::mutex> _l(mPublicLock); |
| // |
| MUINT32 revResult = (MUINT32)REQ_REV_RES_UNKNOWN; |
| if (!acceptRequest(pFrame, &revResult)) { |
| mLogInfo.setMemo(LogInfo::CP_REQ_ACCEPT, P1GET_FRM_NUM(pFrame), |
| P1GET_REQ_NUM(pFrame), MFALSE, revResult); |
| FUNCTION_OUT; |
| return FAILED_TRANSACTION; |
| } |
| mLogInfo.setMemo(LogInfo::CP_REQ_ACCEPT, P1GET_FRM_NUM(pFrame), |
| P1GET_REQ_NUM(pFrame), MTRUE, revResult); |
| // |
| lastFrameRequestInfoUpdate(P1GET_FRM_NUM(pFrame), P1GET_REQ_NUM(pFrame)); |
| // |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_REQ_REV, LogInfo::CP_REQ_RET, |
| P1GET_FRM_NUM(pFrame), P1GET_REQ_NUM(pFrame)); |
| P1_TRACE_F_BEGIN(SLG_I, "P1:queue|Fnum:%d Rnum:%d", P1GET_FRM_NUM(pFrame), |
| P1GET_REQ_NUM(pFrame)); |
| MY_LOGD("active=%d", getActive()); |
| // |
| MBOOL isStartSet = MFALSE; |
| int32_t currReqCnt = 0; |
| currReqCnt = std::atomic_fetch_add_explicit(&mInFlightRequestCnt, 1, |
| std::memory_order_release); |
| P1_TRACE_INT(SLG_B, "P1_request_cnt", |
| std::atomic_load_explicit(&mInFlightRequestCnt, |
| std::memory_order_acquire)); |
| MY_LOGD("InFlightRequestCount++ (%d) => (%d)", currReqCnt, |
| std::atomic_load_explicit(&mInFlightRequestCnt, |
| std::memory_order_acquire)); |
| // |
| if (EN_INIT_REQ_RUN) { |
| if (mInitReqCnt <= (mInitReqNum + mBurstNum)) { |
| mInitReqCnt++; |
| } |
| } |
| // |
| MINT cnt = 0; |
| if (EN_INIT_REQ_RUN && (mInitReqCnt < mInitReqNum)) { |
| P1QueAct newAct; |
| mpTaskCtrl->sessionLock(); |
| mpTaskCollector->enrollAct(&newAct); |
| createAction(&newAct, pFrame); |
| cnt = mpTaskCollector->verifyAct(&newAct); |
| mTagList.set(cnt); |
| mpTaskCtrl->sessionUnLock(); |
| // else if (mInitReqCnt == mInitReqNum) go-on the following flow |
| } else { // for REV_MODE_NORMAL/REV_MODE_CONSERVATIVE |
| #if 1 // restart while queue ready |
| if (!getActive()) { |
| MY_LOGI("HW start +++"); |
| if (mpConCtrl != nullptr && |
| (!EN_INIT_REQ_RUN)) { // init-request, no aid-start |
| mpConCtrl->setAidUsage(MTRUE); |
| } |
| MERROR err = hardwareOps_start(); |
| if ((!(EN_START_CAP || EN_INIT_REQ_RUN)) || (err != OK)) { |
| if (mpConCtrl != nullptr && mpConCtrl->getAidUsage() == MTRUE) { |
| mpConCtrl->cleanAidStage(); |
| } |
| if (mpTimingCheckerMgr != nullptr) { |
| mpTimingCheckerMgr->setEnable(MFALSE); |
| } |
| } |
| if (err != OK) { |
| MY_LOGE("Queue Frame - HW start fail (%d)", err); |
| P1_TRACE_C_END(SLG_I); // "P1:queue" |
| return err; |
| } |
| MY_LOGI("HW start ---"); |
| } |
| #endif |
| if (mpTaskCtrl == nullptr || mpTaskCollector == nullptr) { |
| MY_LOGE("Task Controller or Collector not ready"); |
| P1_TRACE_C_END(SLG_I); // "P1:queue" |
| return BAD_VALUE; |
| } |
| P1QueAct newAct; |
| P1QueAct setAct; |
| NS3Av3::MetaSet_T preSet; |
| P1Act pSetAct = nullptr; |
| mpTaskCtrl->sessionLock(); |
| // |
| mpTaskCollector->enrollAct(&newAct); |
| createAction(&newAct, pFrame); |
| cnt = mpTaskCollector->verifyAct(&newAct); |
| // |
| P1Act pAct = GET_ACT_PTR(pAct, newAct, BAD_VALUE); |
| if (pAct->ctrlSensorStatus == SENSOR_STATUS_CTRL_STANDBY) { |
| MY_LOGI("receive-standby-control"); |
| } else if (pAct->ctrlSensorStatus == SENSOR_STATUS_CTRL_STREAMING) { |
| MY_LOGI("receive-streaming-control"); |
| hardwareOps_streaming(); |
| } |
| // |
| if ((mFirstReceived) && (pAct->reqType == REQ_TYPE_YUV)) { |
| P1QueAct paddingAct; |
| mpTaskCollector->enrollAct(&paddingAct); |
| createAction(&paddingAct, nullptr, REQ_TYPE_PADDING); |
| cnt = mpTaskCollector->verifyAct(&paddingAct); |
| MY_LOGI("add-padding-for-YUV-stall Id:%d Num:%d Type:%d", paddingAct.id(), |
| paddingAct.getNum(), paddingAct.getType()); |
| } |
| mTagList.set(cnt); |
| if (IS_BURST_OFF && mFirstReceived && pAct->getType() == ACT_TYPE_NORMAL) { |
| mpTaskCollector->queryAct(&setAct); |
| pSetAct = setAct.ptr(); // GET_ACT_PTR(pSetAct, firstAct, BAD_VALUE); |
| if (pSetAct != |
| nullptr) { // for the consideration of session locking peroid with 3A |
| // CB and preset, duplicate this MetaSet |
| preSet = pSetAct->metaSet; |
| } else { |
| MY_LOGW("no act ready to PreSet"); |
| } |
| } |
| mpTaskCtrl->sessionUnLock(); |
| if (mp3A && IS_BURST_OFF && mFirstReceived && (pSetAct != nullptr)) { |
| if (preSet.PreSetKey <= P1_PRESET_KEY_NULL) { |
| MY_LOGW("Pre-Set-Meta NOT ready (%d)", preSet.PreSetKey); |
| } else { |
| if (preSet.Dummy > 0) { |
| MY_LOGI("Pre-Set-Meta is dummy (%d)", preSet.Dummy); |
| } |
| MINT32 f_Num = pSetAct->frmNum; |
| MINT32 r_Num = pSetAct->reqNum; |
| std::vector<NS3Av3::MetaSet_T*> ctrlQueue; // only insert once |
| ctrlQueue.push_back(&preSet); |
| if (mMetaLogOp > 0 && ctrlQueue.size() > 0) { |
| P1_LOG_META(*pSetAct, &(ctrlQueue[0]->appMeta), "3A.PreSet-APP"); |
| P1_LOG_META(*pSetAct, &(ctrlQueue[0]->halMeta), "3A.PreSet-HAL"); |
| } |
| mLogInfo.setMemo(LogInfo::CP_PRE_SET_BGN, preSet.PreSetKey, |
| preSet.Dummy, f_Num, r_Num); |
| P1_TRACE_F_BEGIN(SLG_I, "P1:3A-preset|Pkey:%d Fnum:%d Rnum:%d", |
| preSet.PreSetKey, f_Num, r_Num); |
| MY_LOGD("mp3A->preset[%d] +++", preSet.PreSetKey); |
| mp3A->preset(ctrlQueue); |
| MY_LOGD("mp3A->preset[%d] ---", preSet.PreSetKey); |
| P1_TRACE_C_END(SLG_I); // "P1:3A-preset" |
| mLogInfo.setMemo(LogInfo::CP_PRE_SET_END, preSet.PreSetKey, |
| preSet.Dummy, f_Num, r_Num); |
| if (1 <= mLogLevelI) { // P1_LOGI(1) |
| pAct->msg += base::StringPrintf( |
| " | [PreSet][Key:%d] Num(%d) " |
| "Dummy(%d) MetaCnt[APP:%d,HAL:%d]", |
| preSet.PreSetKey, preSet.MagicNum, preSet.Dummy, |
| preSet.appMeta.count(), preSet.halMeta.count()); |
| } |
| } |
| } |
| // |
| if (!mFirstReceived) { |
| if (cnt >= mBurstNum) { |
| mFirstReceived = MTRUE; |
| isStartSet = MTRUE; |
| } // else not-start and not-wait, then try to receive more requests |
| } |
| // |
| if (1 <= mLogLevelI) { // P1_LOGI(1) |
| P1_TRACE_F_BEGIN(SLG_PFL, |
| "P1::REQ_LOG|Mnum:%d SofIdx:%d Fnum:%d " |
| "Rnum:%d FlushSet:0x%x", |
| pAct->magicNum, pAct->sofIdx, pAct->frmNum, pAct->reqNum, |
| pAct->flushSet); |
| pAct->msg += base::StringPrintf( |
| " | [Rev:%d] depth(%d) burst(%d) " |
| "Que[%d]", |
| mReceiveMode, mDepthNum, mBurstNum, mpTaskCollector->remainder()); |
| P1_LOGI(1, "%s", pAct->msg.c_str()); |
| P1_TRACE_C_END(SLG_PFL); // "P1::REQ_LOG" |
| } |
| } |
| // |
| #if 1 // SET_REQUEST_BEFORE_FIRST_DONE |
| if (isStartSet) { |
| if (EN_INIT_REQ_RUN && (!getReady())) { |
| MY_LOGI("HW request +++"); |
| MERROR err = hardwareOps_request(); |
| if (mpConCtrl != nullptr && mpConCtrl->getAidUsage() == MTRUE) { |
| mpConCtrl->cleanAidStage(); |
| } |
| if (mpTimingCheckerMgr != nullptr) { |
| mpTimingCheckerMgr->setEnable(MFALSE); |
| } |
| if (err != OK) { |
| MY_LOGE("Queue Frame - HW request fail (%d)", err); |
| P1_TRACE_C_END(SLG_I); // "P1:queue" |
| return err; |
| } |
| MY_LOGI("HW request ---"); |
| } else if (EN_START_CAP && (!getReady())) { |
| MY_LOGI("HW capture +++"); |
| MERROR err = hardwareOps_capture(); |
| if (mpConCtrl != nullptr && mpConCtrl->getAidUsage() == MTRUE) { |
| mpConCtrl->cleanAidStage(); |
| } |
| if (mpTimingCheckerMgr != nullptr) { |
| mpTimingCheckerMgr->setEnable(MFALSE); |
| } |
| if (err != OK) { |
| MY_LOGE("Queue Frame - HW capture fail (%d)", err); |
| P1_TRACE_C_END(SLG_I); // "P1:queue" |
| return err; |
| } |
| MY_LOGI("HW capture ---"); |
| } else { |
| // onRequestFrameSet(MTRUE); |
| setRequest(MTRUE); |
| } |
| } |
| #endif |
| // |
| if (mpHwStateCtrl != nullptr) { |
| mpHwStateCtrl->checkRequest(); |
| } |
| // |
| inflightMonitoring(IMT_REQ); |
| // |
| P1_TRACE_C_END(SLG_I); // "P1:queue" |
| // |
| FUNCTION_OUT; |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::kick() { |
| FUNCTION_IN; |
| // |
| if ((!getActive()) || (!getReady())) { |
| MY_LOGI("return OK - active(%d) ready(%d)", getActive(), getReady()); |
| return OK; |
| } |
| if (IS_BURST_ON) { |
| MY_LOGI("return OK - BurstNum(%d)", mBurstNum); |
| return OK; |
| } |
| if (CC_UNLIKELY(mpTaskCtrl == nullptr || mpTaskCollector == nullptr)) { |
| return BAD_VALUE; |
| } |
| // |
| { |
| mpTaskCtrl->sessionLock(); |
| MINT cnt = mpTaskCollector->remainder(); |
| P1_TRACE_F_BEGIN(SLG_E, "P1:kick(%d)", cnt); |
| MY_LOGI("cnt(%d)", cnt); |
| while (cnt > 0) { |
| P1QueAct qAct; |
| cnt = mpTaskCollector->requireAct(&qAct); |
| if (qAct.id() > P1ACT_ID_NULL) { |
| P1Act act = GET_ACT_PTR(act, qAct, BAD_VALUE); |
| if (act->ctrlSensorStatus != SENSOR_STATUS_CTRL_NONE) { |
| MY_LOGI("Cannot KICK Standby Ctrl Request - " P1INFO_ACT_STR, |
| P1INFO_ACT_VAR(*act)); |
| } else { |
| MY_LOGI("KICK - " P1INFO_ACT_STR, P1INFO_ACT_VAR(*act)); |
| onReturnFrame(&qAct, FLUSH_KICK, MTRUE); |
| /* DO NOT use this P1QueAct after onReturnFrame() */ |
| } |
| } |
| } |
| mTagList.set(cnt); |
| P1_TRACE_C_END(SLG_E); // "P1:kick" |
| mpTaskCtrl->sessionUnLock(); |
| } |
| // |
| FUNCTION_OUT; |
| // |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::flush(std::shared_ptr<IPipelineFrame> const& pFrame) { |
| return BaseNode::flush(pFrame); |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::flush() { |
| FUNCTION_IN; |
| |
| P1_TRACE_AUTO(SLG_B, "P1:flush"); |
| |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_API_FLUSH_BGN, |
| LogInfo::CP_API_FLUSH_END); |
| |
| kick(); |
| |
| std::lock_guard<std::mutex> _l(mPublicLock); |
| |
| onHandleFlush(MFALSE); |
| |
| // wait until deque thread going back to waiting state; |
| // in case next node receives queue() after flush() |
| |
| FUNCTION_OUT; |
| |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| void P1NodeImp::requestExit() { |
| FUNCTION_IN; |
| |
| // let deque thread back |
| { |
| std::lock_guard<std::mutex> _l(mThreadLock); |
| mExitPending = MTRUE; |
| mThreadCond.notify_all(); |
| } |
| // |
| if (mThread.joinable()) { |
| mThread.join(); |
| } |
| |
| // let cb thread back |
| { |
| std::lock_guard<std::mutex> _l(mStartLock); |
| mStartCond.notify_all(); |
| } |
| |
| FUNCTION_OUT; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| status_t P1NodeImp::readyToRun() { |
| MY_LOGD("readyToRun P1NodeImp thread"); |
| // |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| bool P1NodeImp::threadLoop() { |
| while (this->_threadLoop() == true) { |
| } |
| MY_LOGI("threadLoop exit"); |
| return true; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| bool P1NodeImp::_threadLoop() { |
| // check if going to leave thread |
| P1_TRACE_FUNC(SLG_B); // P1_TRACE_AUTO(SLG_B, "P1:threadLoop"); |
| // |
| { |
| std::unique_lock<std::mutex> lck(mThreadLock); |
| |
| if (!getActive()) { |
| P1_TRACE_S_BEGIN(SLG_S, "P1:wait_active"); |
| MY_LOGD("wait active+"); |
| mThreadCond.wait(lck); |
| MY_LOGD("wait active-"); |
| P1_TRACE_C_END(SLG_S); // "P1:wait_active" |
| } |
| |
| if (mExitPending) { |
| MY_LOGD("leaving active"); |
| return false; |
| } |
| } |
| // |
| if (mpConCtrl != nullptr && mpConCtrl->getAidUsage()) { |
| procedureAid_start(); |
| } |
| // |
| { |
| std::unique_lock<std::mutex> lck(mThreadLock); |
| |
| if (getActive() && !getReady()) { |
| P1_TRACE_S_BEGIN(SLG_S, "P1:wait_ready"); |
| MY_LOGD("wait ready+"); |
| mThreadCond.wait(lck); |
| MY_LOGD("wait ready-"); |
| P1_TRACE_C_END(SLG_S); // "P1:wait_ready" |
| } |
| |
| if (mExitPending) { |
| MY_LOGD("leaving ready"); |
| return false; |
| } |
| } |
| |
| if (mpHwStateCtrl != nullptr) { |
| mpHwStateCtrl->checkThreadStandby(); |
| } |
| |
| // deque buffer, and handle frame and metadata |
| onProcessDequeFrame(); |
| |
| if (!getActive()) { |
| MY_LOGI_IF(getInit(), "HW stopped , exit init"); |
| setInit(MFALSE); |
| } |
| |
| // trigger point for the first time |
| { |
| if (getInit()) { |
| setInit(MFALSE); |
| } |
| } |
| |
| if ((mpDeliverMgr != nullptr) && (mpDeliverMgr->runningGet())) { |
| onProcessDropFrame(MTRUE); |
| } |
| |
| return true; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::setActive(MBOOL active) { |
| std::lock_guard<std::mutex> _l(mActiveLock); |
| mActive = active; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::getActive(void) { |
| std::lock_guard<std::mutex> _l(mActiveLock); |
| return mActive; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::setReady(MBOOL ready) { |
| std::lock_guard<std::mutex> _l(mReadyLock); |
| mReady = ready; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::getReady(void) { |
| std::lock_guard<std::mutex> _l(mReadyLock); |
| return mReady; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::setInit(MBOOL init) { |
| std::lock_guard<std::mutex> _l(mInitLock); |
| mInit = init; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::getInit(void) { |
| std::lock_guard<std::mutex> _l(mInitLock); |
| return mInit; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::setPowerNotify(MBOOL notify) { |
| std::lock_guard<std::mutex> _l(mPowerNotifyLock); |
| mPowerNotify = notify; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::getPowerNotify(void) { |
| std::lock_guard<std::mutex> _l(mPowerNotifyLock); |
| return mPowerNotify; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::setStartState(MUINT8 state) { |
| std::lock_guard<std::mutex> _l(mStartStateLock); |
| mStartState = state; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MUINT8 |
| P1NodeImp::getStartState(void) { |
| std::lock_guard<std::mutex> _l(mStartStateLock); |
| return mStartState; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::setQualitySwitching(MBOOL switching) { |
| std::lock_guard<std::mutex> _l(mQualitySwitchLock); |
| mQualitySwitching = switching; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::getQualitySwitching(void) { |
| std::lock_guard<std::mutex> _l(mQualitySwitchLock); |
| return mQualitySwitching; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::setCurrentBinSize(MSize size) { |
| std::lock_guard<std::mutex> _l(mCurBinLock); |
| mCurBinSize = size; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MSize P1NodeImp::getCurrentBinSize(void) { |
| std::lock_guard<std::mutex> _l(mCurBinLock); |
| return mCurBinSize; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::lastFrameRequestInfoUpdate(MINT32 const frameNum, |
| MINT32 const requestNum) { |
| std::lock_guard<std::mutex> _l(mLastFrmReqNumLock); |
| mLastFrmNum = frameNum; |
| mLastReqNum = requestNum; |
| mLastCbCnt = 0; |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MINT32 |
| P1NodeImp::lastFrameRequestInfoNotice(MINT32* frameNum, |
| MINT32* requestNum, |
| MINT32 const addCbCnt) { |
| std::lock_guard<std::mutex> _l(mLastFrmReqNumLock); |
| *frameNum = mLastFrmNum; |
| *requestNum = mLastReqNum; |
| if (addCbCnt != 0) { |
| mLastCbCnt += (addCbCnt); |
| } |
| return mLastCbCnt; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::syncHelperStart() { |
| std::lock_guard<std::mutex> _l(mSyncHelperLock); |
| if (!mSyncHelperReady) { |
| if (mspSyncHelper != nullptr) { |
| status_t res = mspSyncHelper->start(getOpenId()); |
| if (res == OK) { |
| mSyncHelperReady = MTRUE; |
| } |
| } |
| } |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::syncHelperStop() { |
| std::lock_guard<std::mutex> _l(mSyncHelperLock); |
| if (mSyncHelperReady) { |
| if (mspSyncHelper != nullptr) { |
| status_t res = mspSyncHelper->stop(getOpenId()); |
| if (res == OK) { |
| mSyncHelperReady = MFALSE; |
| } |
| } |
| } |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| void P1NodeImp::ensureStartReady(MUINT8 infoType, MINT32 infoNum) { |
| std::cv_status res; |
| MUINT32 needRetry = P1NODE_START_READY_WAIT_CNT_MAX; |
| if (getActive()) { |
| std::unique_lock<std::mutex> lck(mStartLock); |
| while ((!getReady()) && (needRetry != 0) && |
| ((getStartState() != NSP1Node::START_STATE_READY) && |
| (getStartState() >= NSP1Node::START_STATE_DRV_START))) { |
| res = mStartCond.wait_for( |
| lck, std::chrono::nanoseconds(P1NODE_START_READY_WAIT_INV_NS)); |
| needRetry--; |
| MY_LOGI( |
| "Type(%d) Num(%d) - EnStartCap(%d) EnInitReqRun(%d) - " |
| "StartState(%d) WaitStatus(%d) NeedRetry(%d)", |
| infoType, infoNum, EN_START_CAP, EN_INIT_REQ_RUN, getStartState(), |
| res, needRetry); |
| if (!getActive()) { |
| MY_LOGI("Not Active"); |
| break; |
| } |
| if (res != std::cv_status::timeout) { |
| MY_LOGI("Got Ready"); |
| break; |
| } |
| } |
| } |
| if ((getActive()) && (!getReady())) { |
| MY_LOGE( |
| "Wait StartReady Timeout (%d*%d ms) - " |
| "Type(%d) Num(%d) - EnStartCap(%d) EnInitReqRun(%d) - " |
| "StartState(%d) WaitStatus(%d) NeedRetry(%d)", |
| P1NODE_START_READY_WAIT_CNT_MAX, |
| (MUINT32)(P1NODE_START_READY_WAIT_INV_NS / ONE_MS_TO_NS), infoType, |
| infoNum, EN_START_CAP, EN_INIT_REQ_RUN, getStartState(), res, |
| needRetry); |
| } |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::onSyncEnd() { |
| FUNCTION_IN; |
| // |
| { |
| NS3Av3::IpcPeriSensorData_T data; |
| if (mpAccDetector->getAcceleration(data.acceleration)) |
| mp3A->send3ACtrl(NS3Av3::E3ACtrl_IPC_SetPeriSensorData, |
| reinterpret_cast<MINTPTR>(&data), 0); |
| } |
| MBOOL toSet = MFALSE; |
| if (mpHwStateCtrl != nullptr) { |
| if (mpHwStateCtrl->checkSkipSync()) { |
| MY_LOGI("SyncEND was paused"); |
| return; |
| } |
| MBOOL first = mpHwStateCtrl->checkFirstSync(); |
| MY_LOGI_IF(first, "Got first CB after re-streaming"); |
| if (first && IS_BURST_ON) { |
| toSet = MTRUE; |
| } |
| } |
| // |
| { |
| std::lock_guard<std::mutex> _ll(mFrameSetLock); |
| if (!mFrameSetAlready) { |
| MY_LOGI("should not callback before first set"); |
| return; |
| } |
| if (EN_START_CAP && (!getReady())) { |
| std::lock_guard<std::mutex> _l(mStartCaptureLock); |
| MY_LOGD("StartCaptureState(%d)", mStartCaptureState); |
| if (mStartCaptureState != START_CAP_STATE_READY) { |
| MY_LOGI("should not callback before capture ready (%d)", |
| mStartCaptureState); |
| return; |
| } |
| } |
| } |
| // |
| if (getInit()) { |
| MY_LOGI("sync before frame done"); |
| } |
| // |
| if ((getActive()) && (!getReady())) { |
| ensureStartReady(IHal3ACb::eID_NOTIFY_VSYNC_DONE); |
| } |
| // |
| P1_TRACE_F_BEGIN(SLG_I, "P1:onSyncEnd|TheLastSet-Mnum:%d", mLastSetNum); |
| // |
| if (IS_BURST_OFF || toSet) { |
| setRequest(MFALSE); |
| } |
| // |
| P1_TRACE_C_END(SLG_I); // "P1:onSyncEnd" |
| // |
| FUNCTION_OUT; |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::onSyncBegin(MBOOL initial, |
| NS3Av3::RequestSet_T* reqSet, |
| MUINT32 sofIdx, |
| NS3Av3::CapParam_T* capParam) { |
| FUNCTION_IN; |
| if (mpHwStateCtrl != nullptr) { |
| if (mpHwStateCtrl->checkSkipSync()) { |
| MY_LOGI("SyncBGN was paused"); |
| return; |
| } |
| MBOOL first = mpHwStateCtrl->checkFirstSync(); |
| MY_LOGI_IF(first, "Got first CB after re-streaming"); |
| } |
| // |
| { |
| std::lock_guard<std::mutex> _ll(mFrameSetLock); |
| if (!mFrameSetAlready) { |
| MY_LOGI("should not callback before first set"); |
| return; |
| } |
| // |
| if (EN_START_CAP && (!getReady())) { |
| std::lock_guard<std::mutex> _l(mStartCaptureLock); |
| MY_LOGD("StartCaptureState(%d)", mStartCaptureState); |
| if (mStartCaptureState == START_CAP_STATE_WAIT_CB) { |
| if (capParam != nullptr) { |
| mStartCaptureType = capParam->u4CapType; |
| mStartCaptureIdx = sofIdx; |
| mStartCaptureExp = MAX(capParam->i8ExposureTime, 0); |
| if (reqSet != nullptr && reqSet->vNumberSet.size() > 0 && |
| IS_BURST_OFF) { |
| mLongExp.set(reqSet->vNumberSet[0], mStartCaptureExp); |
| } |
| } |
| mStartCaptureState = START_CAP_STATE_READY; |
| mStartCaptureCond.notify_all(); |
| MY_LOGI( |
| "StartCaptureReady @%d init(%d) Cap-Type(%d)-Idx(%d)" |
| "-Exp(%" PRId64 "ns)", |
| sofIdx, getInit(), mStartCaptureType, mStartCaptureIdx, |
| mStartCaptureExp); |
| return; |
| } else if (mStartCaptureState == START_CAP_STATE_WAIT_REQ) { |
| MY_LOGI("should not callback before capture set (%d)", |
| mStartCaptureState); |
| return; |
| } |
| } |
| } |
| // |
| if (getInit()) { |
| MY_LOGI("sync before frame done"); |
| } |
| // |
| MINT32 magicNum = P1_MAGIC_NUM_NULL; |
| if (reqSet != nullptr && reqSet->vNumberSet.size() > 0) { |
| magicNum = reqSet->vNumberSet[0]; |
| } |
| // |
| if ((getActive()) && (!getReady())) { |
| ensureStartReady(IHal3ACb::eID_NOTIFY_3APROC_FINISH, magicNum); |
| } |
| // |
| P1_TRACE_F_BEGIN(SLG_I, |
| "P1:onSyncBegin|" |
| "CB Mnum:%d SofIdx:%d Exp(ns):%" PRId64 " Type:%d", |
| magicNum, sofIdx, capParam->i8ExposureTime, |
| capParam->u4CapType); |
| // |
| // (1) |
| if ((!initial) && (getReady())) { |
| P1QueJob job(mBurstNum); |
| bool exist = false; |
| { |
| std::lock_guard<std::mutex> _l(mRequestQueueLock); |
| Que_T::iterator it = mRequestQueue.begin(); |
| for (; it != mRequestQueue.end(); it++) { |
| if ((*it).getIdx() == magicNum) { |
| job = *it; |
| for (MUINT8 i = 0; i < job.size(); i++) { |
| P1Act act = GET_ACT_PTR(act, job.edit(i), RET_VOID); |
| act->sofIdx = sofIdx; |
| if (capParam != nullptr) { |
| act->capType = capParam->u4CapType; |
| act->frameExpDuration = MAX(capParam->i8ExposureTime, 0); |
| if (act->capType == NS3Av3::E_CAPTURE_HIGH_QUALITY_CAPTURE |
| /*&& mRawPostProcSupport == MFALSE*/) { // no matter |
| // legacy/non-legacy |
| // platform, HQC need |
| // pure raw |
| if (act->fullRawType != EPipe_PURE_RAW) { |
| act->isRawTypeChanged = MTRUE; |
| MY_LOGI( |
| "HQC (%d) - full raw type change" |
| " (%d => %d)", |
| mRawPostProcSupport, act->fullRawType, EPipe_PURE_RAW); |
| } |
| act->fullRawType = EPipe_PURE_RAW; |
| } |
| if (IS_BURST_OFF) { |
| mLongExp.set(act->magicNum, act->frameExpDuration); |
| } |
| MY_LOGI_IF(((capParam->i8ExposureTime >= 400000000) || |
| (capParam->i8ExposureTime <= 0)), |
| "check CB " |
| "num(%d) cap(%d) exp(%" PRId64 "ns)", |
| magicNum, capParam->u4CapType, |
| capParam->i8ExposureTime); |
| if ((act->capType != NS3Av3::E_CAPTURE_NORMAL) && |
| (act->appFrame != nullptr)) { |
| MY_LOGI("Job(%d) - Cap(%d)(%" PRId64 "ns) - " P1INFO_ACT_STR, |
| job.getIdx(), capParam->u4CapType, |
| capParam->i8ExposureTime, P1INFO_ACT_VAR(*act)); |
| } |
| } else { |
| MY_LOGW("cannot find cap param (%d)", magicNum); |
| } |
| } |
| // |
| if (it != mRequestQueue.begin()) { |
| std::string str; |
| str += base::StringPrintf( |
| "MissingCallback from 3A : " |
| "this CB Mnum(%d) ; current ReqQ[%d] = [ ", |
| magicNum, static_cast<int>(mRequestQueue.size())); |
| Que_T::iterator it = mRequestQueue.begin(); |
| for (; it != mRequestQueue.end(); it++) { |
| str += base::StringPrintf("%d ", (*it).getIdx()); |
| } |
| str += base::StringPrintf("] @ SOF(%d)", sofIdx); |
| MY_LOGW("%s", str.c_str()); |
| } |
| // |
| mRequestQueue.erase(it); |
| exist = true; |
| break; |
| } |
| } |
| } |
| if (exist) { |
| { |
| std::lock_guard<std::mutex> _ll(mTransferJobLock); |
| mTransferJobIdx = job.getIdx(); |
| } |
| // |
| if (OK != onProcessEnqueFrame(&job)) { |
| MY_LOGE("frame en-queue fail (%d)", magicNum); |
| for (MUINT8 i = 0; i < job.size(); i++) { |
| onReturnFrame(&job.edit(i), FLUSH_FAIL, MTRUE); |
| /* DO NOT use this P1QueAct after onReturnFrame() */ |
| } |
| } else { |
| if ( // IS_BURST_OFF && // exclude burst mode |
| (job.size() >= 1)) { |
| P1Act act = GET_ACT_PTR(act, job.edit(0), RET_VOID); |
| if ((act->reqType == REQ_TYPE_NORMAL && act->appFrame != nullptr) && |
| (capParam != nullptr && capParam->metadata.count() > 0)) { |
| requestMetadataEarlyCallback(&(job.edit(0)), STREAM_META_OUT_HAL, |
| &(capParam->metadata)); |
| } |
| } |
| // |
| P1Act pAct = GET_ACT_PTR(pAct, job.edit(0), RET_VOID); |
| if (mpHwStateCtrl != nullptr && |
| pAct->ctrlSensorStatus == SENSOR_STATUS_CTRL_STANDBY) { |
| MBOOL isAct = MFALSE; |
| isAct = mpHwStateCtrl->checkCtrlStandby(pAct->getNum()); |
| // it might call doNotifyDropframe() in DRV->suspend() |
| if ((isAct) && |
| ((mpDeliverMgr != nullptr) && (mpDeliverMgr->runningGet()))) { |
| MY_LOGI("DRV-suspend executed : check drop-frame"); |
| onProcessDropFrame(MTRUE); |
| } |
| } |
| } |
| // |
| { |
| std::lock_guard<std::mutex> _ll(mTransferJobLock); |
| mTransferJobIdx = P1ACT_ID_NULL; |
| if (CC_UNLIKELY(mTransferJobWaiting)) { |
| mTransferJobCond.notify_all(); |
| } |
| } |
| } else { |
| #if (IS_P1_LOGI) |
| std::lock_guard<std::mutex> _l(mRequestQueueLock); |
| std::string str; |
| str += base::StringPrintf("[req(%d)/size(%d)]: ", magicNum, |
| static_cast<int>(mRequestQueue.size())); |
| Que_T::iterator it = mRequestQueue.begin(); |
| for (; it != mRequestQueue.end(); it++) { |
| str += base::StringPrintf("%d ", (*it).getIdx()); |
| } |
| MY_LOGI("%s", str.c_str()); |
| #endif |
| } |
| } |
| // |
| if (IS_BURST_ON) { |
| MBOOL skip = MFALSE; |
| if (mpHwStateCtrl != nullptr) { |
| skip = mpHwStateCtrl->checkSkipSync(); |
| } |
| if (skip) { |
| MY_LOGI("FrameSet was paused"); |
| } else { |
| setRequest(MFALSE); |
| } |
| } |
| // |
| P1_TRACE_C_END(SLG_I); // "P1:onSyncBegin" |
| // |
| inflightMonitoring(IMT_ENQ); |
| // |
| FUNCTION_OUT; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::onProcessEnqueFrame(P1QueJob* job) { |
| FUNCTION_IN; |
| |
| // (1) todo |
| // pass request directly if it's a reprocessing one |
| // |
| // if( mInHalMeta == NULL) { |
| // onDispatchFrame(pFrame); |
| // return; |
| // } |
| |
| // (2) |
| MERROR status = hardwareOps_enque(job); |
| |
| FUNCTION_OUT; |
| return status; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| P1QueJob P1NodeImp::getProcessingFrame_ByNumber(MINT32 magicNum) { |
| FUNCTION_IN; |
| P1QueJob job(mBurstNum); |
| |
| std::lock_guard<std::mutex> _l(mProcessingQueueLock); |
| if (mProcessingQueue.empty()) { |
| MY_LOGE("mProcessingQueue is empty"); |
| return job; |
| } |
| |
| Que_T::iterator it = mProcessingQueue.begin(); |
| for (; it != mProcessingQueue.end(); it++) { |
| if ((*it).getIdx() == magicNum) { |
| break; |
| } |
| } |
| if (it == mProcessingQueue.end()) { |
| MY_LOGI("cannot find the right act for num: %d", magicNum); |
| job.clear(); |
| return job; |
| } else { |
| job = *it; |
| mProcessingQueue.erase(it); |
| mProcessingQueueCond.notify_all(); |
| } |
| |
| FUNCTION_OUT; |
| // |
| return job; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::getProcessingFrame_ByAddr(IImageBuffer* const imgBuffer, |
| MINT32 magicNum, |
| P1QueJob* job) { |
| FUNCTION_IN; |
| |
| MBOOL ret = MFALSE; |
| if (imgBuffer == nullptr) { |
| MY_LOGE("imgBuffer == NULL"); |
| return ret; |
| } |
| |
| // get the right act from mProcessingQueue |
| MINT32 gotNum = 0; |
| std::vector<MINT32> |
| vStoreNum; // not reserve since it will not insert in the most case |
| vStoreNum.clear(); |
| { |
| std::lock_guard<std::mutex> _l(mProcessingQueueLock); |
| if (mProcessingQueue.empty()) { |
| MY_LOGE("ProQ is empty"); |
| return ret; |
| } |
| // |
| Que_T::iterator it = mProcessingQueue.begin(); |
| for (; it != mProcessingQueue.end(); it++) { |
| P1Act act = GET_ACT_PTR(act, (*it).edit(0), MFALSE); |
| if (imgBuffer == act->streamBufImg[STREAM_IMG_OUT_FULL].spImgBuf.get() || |
| imgBuffer == |
| act->streamBufImg[STREAM_IMG_OUT_OPAQUE].spImgBuf.get() || |
| imgBuffer == |
| act->streamBufImg[STREAM_IMG_OUT_RESIZE].spImgBuf.get() || |
| imgBuffer == act->streamBufImg[STREAM_IMG_OUT_LCS].spImgBuf.get() || |
| imgBuffer == act->streamBufImg[STREAM_IMG_OUT_RSS].spImgBuf.get()) { |
| gotNum = (*it).getIdx(); |
| if ((*it).getIdx() == magicNum) { |
| ret = MTRUE; |
| } else { |
| #if SUPPORT_PERFRAME_CTRL |
| MY_LOGE("magicNum from driver(%d), should(%d)", magicNum, |
| (*it).getIdx()); |
| #else |
| if ((magicNum & P1NODE_COMMON_MAGICNUM_MASK) != 0) { |
| MY_LOGW("magicNum from driver(0x%x) is uncertain", magicNum); |
| ret = MFALSE; |
| } else { |
| ret = MTRUE; |
| MY_LOGW("magicNum from driver(%d), should(%d)", magicNum, |
| (*it).getIdx()); |
| } |
| #endif |
| // reset act from 3A info |
| for (size_t i = 0; i < (*it).size(); i++) { |
| P1Act pAct = GET_ACT_PTR(pAct, (*it).edit(i), MFALSE); |
| pAct->capType = NS3Av3::E_CAPTURE_NORMAL; |
| pAct->frameExpDuration = 0; |
| } |
| } |
| break; |
| } |
| } |
| // |
| if (it == mProcessingQueue.end()) { |
| MY_LOGE("no act with imagebuf(%p), num(%d)", imgBuffer, magicNum); |
| #if 1 // dump ProcessingQ info |
| char const* str[STREAM_IMG_NUM] = {"YUV-in", "RAW-in", "OPQ", "IMG", |
| "RRZ", "LCS", "RSS"}; |
| for (Que_T::iterator j = mProcessingQueue.begin(); |
| j != mProcessingQueue.end(); j++) { |
| for (size_t i = 0; i < (*j).size(); i++) { |
| P1Act act = GET_ACT_PTR(act, (*j).edit(i), MFALSE); |
| MY_LOGW("[ProQ] [%zu] : num(%d)", i, act->magicNum); |
| for (int s = STREAM_ITEM_START; s < STREAM_IMG_NUM; s++) { |
| if (act->streamBufImg[s].bExist && act->streamBufImg[s].spImgBuf) { |
| std::shared_ptr<IImageBuffer> pBuf = |
| act->streamBufImg[s].spImgBuf; |
| MY_LOGW("[ProQ] [%zu] : %s(%p)(P:%p)(V:%p)", i, |
| ((str[s] != nullptr) ? str[s] : "UNKNOWN"), |
| reinterpret_cast<void*>(pBuf.get()), |
| reinterpret_cast<void*>(pBuf->getBufPA(0)), |
| reinterpret_cast<void*>(pBuf->getBufVA(0))); |
| } |
| } |
| } |
| } |
| #endif |
| } else { |
| // |
| if (it != mProcessingQueue.begin()) { |
| size_t queSize = mProcessingQueue.size(); |
| MINT queNum = 0; |
| Que_T::iterator it_stored = mProcessingQueue.begin(); |
| for (; it_stored < it; it_stored++) { |
| for (size_t i = 0; i < (*it_stored).size(); i++) { |
| queNum = ((*it_stored).edit(i).getNum()); |
| vStoreNum.push_back(queNum); |
| MY_LOGI( |
| "Non-Dequeued frame(Mnum:%d) in ProcQue[%zu] " |
| "current(%d)", |
| queNum, queSize, gotNum); |
| } |
| } |
| } |
| *job = *it; |
| mProcessingQueue.erase(it); |
| mProcessingQueueCond.notify_all(); |
| MY_LOGD("magic: %d", magicNum); |
| } |
| } // mProcessingQueueLock.unlock(); |
| // avoid to execute mpHwStateCtrl functions under mProcessingQueueLock |
| MBOOL isPauseDrop = MFALSE; |
| if (mpHwStateCtrl != nullptr) { |
| if (CC_UNLIKELY(gotNum > 0 && mpHwStateCtrl->checkDoneNum(gotNum))) { |
| for (size_t idx = 0; idx < vStoreNum.size(); idx++) { |
| MY_LOGI("DropStoreNum[%zu] : %d", idx, vStoreNum[idx]); |
| mpHwStateCtrl->setDropNum(vStoreNum[idx]); |
| } |
| isPauseDrop = MTRUE; |
| } |
| } |
| if (CC_UNLIKELY((!vStoreNum.empty()) && (!isPauseDrop))) { |
| size_t nSize = vStoreNum.size(); |
| if (nSize > 0 && (vStoreNum[0] + P1NODE_DEF_PROCESS_DEPTH) < gotNum) { |
| MY_LOGW( |
| "[De-queued Frame Skipped] NonDequeuedFrameCount[%zu]:(%d)" |
| " - CurrentDequeuedFrameMnum(%d)" |
| " - Please Check the DRV Dequeue/Drop Flow", |
| nSize, vStoreNum[0], gotNum); |
| } |
| for (size_t idx = 0; idx < nSize; idx++) { |
| MY_LOGI("NonDequeued[%zu/%zu] = FrameMnum(%d) - current(%d)", idx, nSize, |
| vStoreNum[idx], gotNum); |
| } |
| } |
| // |
| FUNCTION_OUT; |
| // |
| return ret; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::onCheckDropFrame(void) { |
| MUINT cnt = 0; |
| MINT32 num = 0; |
| if (mpHwStateCtrl != nullptr) { |
| do { |
| num = mpHwStateCtrl->getDropNum(); |
| if (num > 0) { |
| std::lock_guard<std::mutex> _l(mDropQueueLock); |
| mDropQueue.push_back(num); |
| cnt++; |
| } |
| } while (num > 0); |
| } |
| if ((cnt > 0) && (mpDeliverMgr != nullptr) && (mpDeliverMgr->runningGet())) { |
| MY_LOGI("check drop frame (%d)", cnt); |
| onProcessDropFrame(MTRUE); |
| } |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::onProcessDropFrame(MBOOL isTrigger) { |
| mDropQueueLock.lock(); |
| if (mDropQueue.empty()) { |
| mDropQueueLock.unlock(); |
| return OK; |
| } |
| std::vector<P1QueAct> |
| actQ; // not reserve since it will not insert in the most case |
| for (size_t i = 0; i < mDropQueue.size(); i++) { |
| P1QueJob job = getProcessingFrame_ByNumber(mDropQueue[i]); |
| // if getProcessingFrame_ByNumber can not find the job |
| // the job set size is 0 |
| for (MUINT8 i = 0; i < job.size(); i++) { |
| P1QueAct act = job.edit(i); |
| actQ.push_back(act); |
| } |
| MY_LOGI("drop[%zu/%zu]: %d", i, mDropQueue.size(), mDropQueue[i]); |
| P1_LOGI(0, "DropQueue[%zu/%zu] = %d", i, mDropQueue.size(), mDropQueue[i]); |
| } |
| mDropQueue.clear(); |
| mDropQueueLock.unlock(); |
| // |
| for (size_t i = 0; i < actQ.size(); i++) { |
| // |
| P1Act pAct = GET_ACT_PTR(pAct, actQ.at(i), BAD_VALUE); |
| if (IS_BURST_OFF) { |
| mLongExp.reset(pAct->magicNum); |
| } |
| if (IS_LMV(mpConnectLMV) && (pAct->buffer_eiso != NULL) && getActive()) { |
| MY_LOGD("processDropFrame"); |
| mpConnectLMV->processDropFrame(&(pAct->buffer_eiso)); |
| } |
| pAct->exeState = EXE_STATE_DONE; |
| onReturnFrame(&actQ.at(i), FLUSH_DROP, |
| ((isTrigger) && (i == (actQ.size() - 1))) ? MTRUE : MFALSE); |
| /* DO NOT use this P1QueAct after onReturnFrame() */ |
| } |
| |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::onProcessDequeFrame() { |
| #if 0 |
| // [FIXME] temp-WA for DRV currently not implement self-signal |
| // the dequeue might be blocked while en-queue empty |
| // it should be removed after DRV self-signal ready |
| { |
| std::lock_guard<std::mutex> _ll(mProcessingQueueLock); |
| if (mProcessingQueue.empty()) { |
| return OK; |
| } |
| } |
| #endif |
| |
| FUNCTION_IN; |
| |
| MERROR ret = OK; |
| QBufInfo deqBuf; |
| if (hardwareOps_deque(&deqBuf) != OK) { |
| MY_LOGW("hardwareOps_deque error"); |
| return BAD_VALUE; |
| } |
| |
| if (deqBuf.mvOut.size() == 0) { |
| MBOOL normal_case = (!getActive()); |
| if ((!normal_case) && (mpHwStateCtrl != nullptr)) { |
| normal_case = (mpHwStateCtrl->checkBufferState()); |
| } |
| MY_LOGI("DeqBuf Out Size is 0 (act:%d,%d)", getActive(), normal_case); |
| return ((normal_case) ? OK : BAD_VALUE); |
| } |
| |
| MY_LOGI("HwLockProcessWait +++"); |
| std::lock_guard<std::mutex> _l(mHardwareLock); |
| MY_LOGI("HwLockProcessWait ---"); |
| |
| P1QueJob job(mBurstNum); |
| MBOOL match = getProcessingFrame_ByAddr( |
| deqBuf.mvOut[0].mBuffer, deqBuf.mvOut[0].mMetaData.mMagicNum_hal, &job); |
| { |
| std::unique_lock<std::mutex> _ll(mTransferJobLock); |
| std::cv_status res; |
| MUINT32 needRetry = P1NODE_TRANSFER_JOB_WAIT_CNT_MAX; |
| while ((match) && (mTransferJobIdx != P1ACT_ID_NULL) && |
| (mTransferJobIdx == job.getIdx()) && (needRetry != 0)) { |
| mTransferJobWaiting = MTRUE; |
| res = mTransferJobCond.wait_for( |
| _ll, std::chrono::nanoseconds(P1NODE_TRANSFER_JOB_WAIT_INV_NS)); |
| needRetry--; |
| MY_LOGI( |
| "TransferJob(%d) ThisJob(%d) - WaitStatus(%d) " |
| "NeedRetry(%d)", |
| mTransferJobIdx, job.getIdx(), res, needRetry); |
| if (res != std::cv_status::timeout) { |
| MY_LOGI("Got Job"); |
| break; |
| } |
| } |
| mTransferJobWaiting = MFALSE; |
| if ((res == std::cv_status::timeout) && (mTransferJobIdx == job.getIdx())) { |
| MY_LOGE("TransferJob(%d) Not-Ready : (%d)", mTransferJobIdx, res); |
| } |
| } |
| onCheckDropFrame(); // must call after getProcessingFrame_ByAddr() |
| // |
| if (IS_BURST_OFF) { |
| mLongExp.reset(deqBuf.mvOut[0].mMetaData.mMagicNum_hal); |
| } |
| // |
| if (!findPortBufIndex(deqBuf, &job)) { |
| return BAD_VALUE; |
| } |
| // |
| for (MUINT8 i = 0; i < (MUINT8)job.size(); i++) { |
| P1QueAct qAct = job.edit(i); |
| P1Act act = GET_ACT_PTR(act, qAct, BAD_VALUE); |
| NS3Av3::MetaSet_T result3A; |
| // camera display systrace - DeQ |
| if (act->appFrame != nullptr) { |
| MINT64 const timestamp = deqBuf.mvOut[i].mMetaData.mTimeStamp; |
| P1_TRACE_F_BEGIN( |
| SLG_B, // add information |
| "Cam:%d:IspP1:deq|timestamp(ns):%" PRId64 " duration(ns):%" PRId64 |
| " request:%d frame:%d", |
| getOpenId(), timestamp, NSCam::Utils::getTimeInNs() - timestamp, |
| act->appFrame->getRequestNo(), act->appFrame->getFrameNo()); |
| P1_TRACE_C_END(SLG_B); // "IspP1:deq" |
| } |
| |
| MY_LOGD("job(%d)[%d] = act(%d)", job.getIdx(), i, act->magicNum); |
| mTagDeq.set(qAct.getNum()); |
| #if SUPPORT_3A |
| { |
| std::lock_guard<std::mutex> _ssl(mStopSttLock); |
| if (getActive() && mp3A && act->reqType == REQ_TYPE_NORMAL) { |
| MBOOL drop_notify = MFALSE; |
| MINT32 ret = 0; |
| mp3A->notifyP1Done(act->magicNum); |
| if (match && act->capType == NS3Av3::E_CAPTURE_HIGH_QUALITY_CAPTURE) { |
| P1_TRACE_F_BEGIN(SLG_I, |
| "P1:3A-getCur|" |
| "Mnum:%d SofIdx:%d Fnum:%d Rnum:%d", |
| act->magicNum, act->sofIdx, act->frmNum, |
| act->reqNum); |
| MY_LOGD("mp3A->getCur(%d) +++", act->magicNum); |
| ret = mp3A->getCur(act->magicNum, &result3A); |
| if (ret < 0) { // 0:success |
| drop_notify = MTRUE; |
| MY_LOGI("drop-frame by 3A GetC(%d) @ (%d)(%d:%d)", ret, |
| act->magicNum, act->frmNum, act->reqNum); |
| } |
| MY_LOGD("mp3A->getCur(%d) ---", act->magicNum); |
| P1_TRACE_C_END(SLG_I); // "P1:3A-getCur" |
| } else { |
| P1_TRACE_F_BEGIN(SLG_I, |
| "P1:3A-get|" |
| "Mnum:%d SofIdx:%d Fnum:%d Rnum:%d", |
| act->magicNum, act->sofIdx, act->frmNum, |
| act->reqNum); |
| MY_LOGD("mp3A->get(%d) +++", act->magicNum); |
| ret = mp3A->get(act->magicNum, &result3A); |
| if (ret < 0) { // 0:success |
| drop_notify = MTRUE; |
| MY_LOGI("drop-frame by 3A Get(%d) @ (%d)(%d:%d)", ret, |
| act->magicNum, act->frmNum, act->reqNum); |
| } |
| MY_LOGD("mp3A->get(%d) ---", act->magicNum); |
| P1_TRACE_C_END(SLG_I); // "P1:3A-get" |
| } |
| IMetadata::IEntry entry; |
| entry = result3A.appMeta.entryFor(MTK_TONEMAP_START); |
| if (entry.tag() != IMetadata::IEntry::BAD_TAG) { |
| MY_LOGD("find the entry for MTK_TONEMAP_START *****"); |
| MUINT32 t; |
| for (t = MTK_TONEMAP_START; t < MTK_TONEMAP_MODE; t++) { |
| result3A.appMeta.remove(t); |
| } |
| } |
| entry = result3A.appMeta.entryFor(MTK_EDGE_MODE); |
| if (entry.tag() != IMetadata::IEntry::BAD_TAG) { |
| result3A.appMeta.remove(MTK_EDGE_MODE); |
| } |
| entry = result3A.appMeta.entryFor(MTK_NOISE_REDUCTION_MODE); |
| if (entry.tag() != IMetadata::IEntry::BAD_TAG) { |
| result3A.appMeta.remove(MTK_NOISE_REDUCTION_MODE); |
| } |
| entry = result3A.appMeta.entryFor(MTK_JPEG_QUALITY); |
| if (entry.tag() != IMetadata::IEntry::BAD_TAG) { |
| result3A.appMeta.remove(MTK_JPEG_QUALITY); |
| } |
| entry = result3A.appMeta.entryFor(MTK_JPEG_THUMBNAIL_QUALITY); |
| if (entry.tag() != IMetadata::IEntry::BAD_TAG) { |
| result3A.appMeta.remove(MTK_JPEG_THUMBNAIL_QUALITY); |
| } |
| P1_LOG_META(*act, &(result3A.appMeta), "3A.Get-APP"); |
| P1_LOG_META(*act, &(result3A.halMeta), "3A.Get-HAL"); |
| if (!match) { |
| act->setFlush(FLUSH_MIS_BUFFER); |
| } |
| if (drop_notify) { |
| act->setFlush(FLUSH_MIS_RESULT); |
| match = MFALSE; |
| } |
| } |
| } |
| #endif |
| |
| // check the ReqExpRec |
| if (match && (act->expRec != EXP_REC_NONE)) { |
| switch (act->reqType) { |
| case REQ_TYPE_NORMAL: |
| MY_LOGI("check ExpRec " P1INFO_ACT_STR, P1INFO_ACT_VAR(*act)); |
| break; |
| default: // REQ_TYPE_INITIAL/REQ_TYPE_DUMMY/REQ_TYPE_PADDING |
| MY_LOGI("ExpRec " P1INFO_ACT_STR, P1INFO_ACT_VAR(*act)); |
| break; |
| } |
| } |
| // check the result of raw type |
| if (match) { |
| MUINT32 port_index = act->portBufIndex[P1_OUTPUT_PORT_IMGO]; |
| if (port_index != P1_PORT_BUF_IDX_NONE) { |
| MBOOL raw_match = MTRUE; |
| MUINT32 res_raw = deqBuf.mvOut[port_index].mMetaData.mRawType; |
| MINT64 set_raw = (res_raw == (MUINT32)EPipe_PROCESSED_RAW) |
| ? (MINT64)(eIMAGE_DESC_RAW_TYPE_PROCESSED) |
| : (MINT64)(eIMAGE_DESC_RAW_TYPE_PURE); |
| if ((act->fullRawType == EPipe_PROCESSED_RAW) && |
| res_raw != (MUINT32)EPipe_PROCESSED_RAW) { |
| raw_match = MFALSE; |
| // only check Processed-Raw with (mRawType == EPipe_PROCESSED_RAW) |
| // in Pure-Raw, it would be EPipe_PURE_RAW or others |
| } |
| |
| if (!raw_match) { |
| MY_LOGE("RawType mismatch DEQ(%d) REQ(%d)" P1INFO_ACT_STR, res_raw, |
| act->fullRawType, P1INFO_ACT_VAR(*act)); |
| #if 1 // flush this frame |
| act->setFlush(FLUSH_MIS_RAW); |
| match = MFALSE; |
| #endif |
| } else { |
| IImageBuffer* pBuf = deqBuf.mvOut[port_index].mBuffer; |
| if (pBuf != nullptr) { |
| MBOOL res = |
| pBuf->setImgDesc(eIMAGE_DESC_ID_RAW_TYPE, set_raw, MTRUE); |
| MY_LOGD("ImgBufRawType(%" PRId64 ") %d", set_raw, res); |
| } |
| } |
| } |
| } |
| act->frameTimeStamp = deqBuf.mvOut[i].mMetaData.mTimeStamp; |
| act->frameTimeStampBoot = deqBuf.mvOut[i].mMetaData.mTimeStamp_B; |
| act->exeState = EXE_STATE_DONE; |
| act->isReadoutReady = MTRUE; |
| |
| if (1 <= mLogLevelI) { |
| MUINT32 index = i; |
| std::string strInfo(""); |
| strInfo += base::StringPrintf("[P1::DEQ]" P1INFO_ACT_STR " job(%d/%d) ", |
| P1INFO_ACT_VAR(*act), index, mBurstNum); |
| for (size_t n = index; n < deqBuf.mvOut.size(); n += mBurstNum) { |
| if (deqBuf.mvOut[n].mPortID.index == PORT_IMGO.index) { |
| strInfo += base::StringPrintf( |
| "IMG(%s) ", |
| (deqBuf.mvOut[n].mMetaData.mRawType == EPipe_PROCESSED_RAW) |
| ? "proc" |
| : "pure"); |
| } else if (deqBuf.mvOut[n].mPortID.index == PORT_RRZO.index) { |
| MRect crop_s = deqBuf.mvOut[n].mMetaData.mCrop_s; |
| MRect crop_d = deqBuf.mvOut[n].mMetaData.mCrop_d; |
| MSize size_d = deqBuf.mvOut[n].mMetaData.mDstSize; |
| strInfo += base::StringPrintf( |
| "RRZ%d(%d-%d-%dx%d)(%d-%d-%dx%d)(%dx%d) ", mIsBinEn, crop_s.p.x, |
| crop_s.p.y, crop_s.s.w, crop_s.s.h, crop_d.p.x, crop_d.p.y, |
| crop_d.s.w, crop_d.s.h, size_d.w, size_d.h); |
| } |
| } |
| strInfo += base::StringPrintf( |
| "T-ns(EXP: %" PRId64 |
| ")" |
| "(SOF: m_%" PRId64 " b_%" PRId64 ")(SS: %" PRId64 ") ", |
| act->frameExpDuration, act->frameTimeStamp, act->frameTimeStampBoot, |
| ((act->frameTimeStampBoot != 0) |
| ? (act->frameTimeStampBoot - act->frameExpDuration) |
| : ((act->frameTimeStamp != 0) |
| ? (act->frameTimeStamp - act->frameExpDuration) |
| : (0)))); |
| act->res.clear(); |
| act->res += strInfo; |
| } |
| |
| if (!match || act->getType() == ACT_TYPE_INTERNAL || !getActive()) { |
| FLUSH_TYPE type = FLUSH_MIS_UNCERTAIN; |
| if (!act->getFlush()) { // if flush type did not set |
| if (act->getType() == ACT_TYPE_INTERNAL) { |
| if (act->reqType == REQ_TYPE_INITIAL) { |
| type = FLUSH_INITIAL; |
| } else if (act->reqType == REQ_TYPE_PADDING) { |
| type = FLUSH_PADDING; |
| } else if (act->reqType == REQ_TYPE_DUMMY) { |
| type = FLUSH_DUMMY; |
| } else { |
| type = FLUSH_MIS_UNCERTAIN; |
| } |
| } else { |
| type = FLUSH_INACTIVE; |
| } |
| } |
| onReturnFrame(&qAct, type, MTRUE); |
| /* DO NOT use this P1QueAct after onReturnFrame() */ |
| ret = BAD_VALUE; |
| } else { |
| IMetadata resultAppend; |
| IMetadata inAPP, inHAL; |
| // |
| if (IS_LMV(mpConnectLMV)) { |
| MBOOL enEIS = IS_PORT(CONFIG_PORT_EISO, mConfigPort); |
| MBOOL enRRZ = IS_PORT(CONFIG_PORT_RRZO, mConfigPort); |
| MUINT32 idxEIS = act->portBufIndex[P1_OUTPUT_PORT_EISO]; |
| MUINT32 idxRRZ = act->portBufIndex[P1_OUTPUT_PORT_RRZO]; |
| if (OK == act->frameMetadataGet(STREAM_META_IN_APP, &inAPP) && |
| OK == act->frameMetadataGet(STREAM_META_IN_HAL, &inHAL)) { |
| MBOOL bIsBinEn = |
| (act->refBinSize == mSensorParams.size) ? MFALSE : MTRUE; |
| mpConnectLMV->processResult( |
| bIsBinEn, enEIS, enRRZ, &inAPP, &inHAL, &result3A, mp3A, |
| act->magicNum, act->sofIdx, mLastSofIdx, act->uniSwitchState, |
| deqBuf, idxEIS, idxRRZ, &resultAppend); |
| } else { |
| } |
| } |
| #if 1 // for RSSO update buffer |
| if (IS_OUT(REQ_OUT_RSSO, act->reqOutSet) && |
| (!IS_EXP(EXP_EVT_NOBUF_RSSO, act->expRec))) { |
| MUINT32 port_index = act->portBufIndex[P1_OUTPUT_PORT_RSSO]; |
| std::shared_ptr<IImageBuffer> spImgBuf = |
| act->streamBufImg[STREAM_IMG_OUT_RSS].spImgBuf; |
| if (port_index != P1_PORT_BUF_IDX_NONE && spImgBuf != nullptr) { |
| MSize size = deqBuf.mvOut[port_index].mMetaData.mDstSize; |
| MY_LOGD("RSSO data size (%dx%d)", size.w, size.h); |
| |
| IMetadata::IEntry entry(MTK_P1NODE_RSS_SIZE); |
| entry.push_back(size, Type2Type<MSize>()); |
| resultAppend.update(MTK_P1NODE_RSS_SIZE, entry); |
| } |
| } |
| #endif |
| |
| #if SUPPORT_FSC |
| if (mpFSC != nullptr) { |
| MBOOL bIsBinEn = |
| (act->refBinSize == mSensorParams.size) ? MFALSE : MTRUE; |
| MUINT32 idxRSS = P1_PORT_BUF_IDX_NONE; |
| MUINT32 idxRRZ = act->portBufIndex[P1_OUTPUT_PORT_RRZO]; |
| if (IS_OUT(REQ_OUT_RSSO, act->reqOutSet) && |
| (!IS_EXP(EXP_EVT_NOBUF_RSSO, act->expRec)) && |
| act->streamBufImg[STREAM_IMG_OUT_RSS].spImgBuf != nullptr) { |
| idxRSS = act->portBufIndex[P1_OUTPUT_PORT_RSSO]; |
| } |
| act->frameMetadataGet(STREAM_META_IN_APP, &inAPP); |
| act->frameMetadataGet(STREAM_META_IN_HAL, &inHAL); |
| mpFSC->processResult(bIsBinEn, &inAPP, &inHAL, &result3A, mp3A, |
| act->magicNum, deqBuf, idxRSS, idxRRZ, i, |
| &resultAppend); // get FSC resultAppend |
| } |
| #endif |
| mLastSofIdx = act->sofIdx; |
| onProcessResult(&qAct, deqBuf, result3A, resultAppend, i); |
| /* DO NOT use this P1QueAct/P1Act after onProcessResult() */ |
| ret = OK; |
| } |
| } |
| if (IS_PORT(CONFIG_PORT_EISO, mConfigPort) && getActive()) { |
| if (IS_LMV(mpConnectLMV)) { |
| mpConnectLMV->processDequeFrame(&deqBuf); |
| } |
| } |
| // |
| inflightMonitoring(IMT_DEQ); |
| |
| FUNCTION_OUT; |
| |
| return ret; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::onHandleFlush(MBOOL wait, MBOOL isInitReqOff) { |
| FUNCTION_IN; |
| P1_TRACE_S_BEGIN(SLG_S, "P1:HandleFlush"); |
| |
| // wake up cb thread. |
| { |
| std::lock_guard<std::mutex> _l(mStartLock); |
| mStartCond.notify_all(); |
| } |
| |
| // stop hardware |
| if (CC_LIKELY(!wait)) { |
| hardwareOps_stop(); // include hardware and 3A |
| } |
| |
| // check the state |
| if (CC_UNLIKELY(!mFirstReceived)) { |
| if (EN_START_CAP) { |
| MY_LOGE( |
| "REQUEST-NOT-READY in start capture flow - " |
| "enableCaptureFlow(%d)", |
| mEnableCaptureFlow); |
| mLogInfo.inspect(LogInfo::IT_STOP_NO_REQ_IN_CAPTURE); |
| } |
| if (EN_INIT_REQ_RUN) { |
| MY_LOGE( |
| "REQUEST-NOT-READY in initial request flow - " |
| "initRequest(%d) : ReceivedCnt(%d) < RequiredNum(%d)", |
| mInitReqSet, mInitReqCnt, mInitReqNum); |
| mLogInfo.inspect(LogInfo::IT_STOP_NO_REQ_IN_REQUEST); |
| } |
| if ((!EN_START_CAP) && (!EN_INIT_REQ_RUN)) { |
| MY_LOGI("Request Not Received"); |
| mLogInfo.inspect(LogInfo::IT_STOP_NO_REQ_IN_GENERAL); |
| } |
| } |
| |
| { |
| // by flush() or uninit() or eventStreamingOff() |
| if (EN_INIT_REQ_CFG) { // in flush() -> queue() flow, for fast switching, |
| // it will run InitReq flow again, |
| mInitReqNum = |
| mInitReqSet * |
| mBurstNum; // exclude eventStreamingOn case (by mInitReqOff = MTRUE) |
| mInitReqCnt = 0; |
| mInitReqOff = isInitReqOff; |
| if (!EN_INIT_REQ_RUN) { |
| MY_LOGI("Disable - InitReq Set:%d Num:%d Cnt:%d Off:%d", mInitReqSet, |
| mInitReqNum, mInitReqCnt, mInitReqOff); |
| } |
| } |
| } |
| |
| // |
| { |
| mpTaskCtrl->sessionLock(); |
| MINT cnt = mpTaskCollector->remainder(); |
| while (cnt > 0) { |
| P1QueAct qAct; |
| cnt = mpTaskCollector->requireAct(&qAct); |
| if (qAct.id() > P1ACT_ID_NULL) { |
| onReturnFrame(&qAct, FLUSH_COLLECTOR, MFALSE); |
| /* DO NOT use this P1QueAct after onReturnFrame() */ |
| } |
| } |
| mTagList.set(cnt); |
| mpTaskCtrl->sessionUnLock(); |
| } |
| |
| // (1) clear request queue |
| { |
| std::lock_guard<std::mutex> _l(mRequestQueueLock); |
| // P1_LOGD("Check-RQ (%d)", mRequestQueue.size()); |
| while (!mRequestQueue.empty()) { |
| P1QueJob job = *mRequestQueue.begin(); |
| mRequestQueue.erase(mRequestQueue.begin()); |
| for (MUINT8 i = 0; i < job.size(); i++) { |
| P1QueAct qAct = job.edit(i); |
| onReturnFrame(&qAct, FLUSH_REQUESTQ, MFALSE); |
| /* DO NOT use this P1QueAct after onReturnFrame() */ |
| } |
| } |
| } |
| |
| // (2) clear processing queue |
| // wait until processing frame coming out |
| if (CC_UNLIKELY(wait)) { |
| std::unique_lock<std::mutex> _lck(mProcessingQueueLock); |
| while (!mProcessingQueue.empty()) { |
| mProcessingQueueCond.wait(_lck); |
| } |
| } else { |
| // must guarantee hardware has been stopped. |
| std::lock_guard<std::mutex> _l(mProcessingQueueLock); |
| while (!mProcessingQueue.empty()) { |
| P1QueJob job = *mProcessingQueue.begin(); |
| mProcessingQueue.erase(mProcessingQueue.begin()); |
| for (MUINT8 i = 0; i < job.size(); i++) { |
| P1QueAct qAct = job.edit(i); |
| onReturnFrame(&qAct, FLUSH_PROCESSQ, MFALSE); |
| /* DO NOT use this P1QueAct after onReturnFrame() */ |
| } |
| } |
| } |
| |
| // (3) TODO:clear dummy queue |
| |
| // (4) clear drop frame queue |
| onProcessDropFrame(); |
| |
| if (CC_UNLIKELY(mpDeliverMgr != nullptr && !mpDeliverMgr->waitFlush(MTRUE))) { |
| MY_LOGW("request not done"); |
| } |
| |
| // (5) clear all |
| mRequestQueue.clear(); // suppose already clear |
| mProcessingQueue.clear(); // suppose already clear |
| mpTaskCtrl->reset(); |
| mLastNum = 1; |
| |
| P1_TRACE_C_END(SLG_S); // "P1:HandleFlush" |
| FUNCTION_OUT; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| void P1NodeImp::doNotifyCb(MINT32 _msgType, |
| MINTPTR _ext1, |
| MINTPTR _ext2, |
| MINTPTR _ext3) { |
| FUNCTION_IN; |
| // |
| if (_msgType == IHal3ACb::eID_NOTIFY_3APROC_FINISH) { |
| MINT32 magicNum = P1_MAGIC_NUM_NULL; |
| NS3Av3::RequestSet_T* pReqSet = |
| reinterpret_cast<NS3Av3::RequestSet_T*>(_ext1); |
| if (pReqSet != nullptr && pReqSet->vNumberSet.size() > 0) { |
| magicNum = pReqSet->vNumberSet[0]; |
| } |
| MUINT32 sofIdx = (MUINT32)(_ext2); |
| mLogInfo.setMemo(LogInfo::CP_CB_PROC_REV, _msgType, magicNum, sofIdx); |
| } else if (_msgType == IHal3ACb::eID_NOTIFY_VSYNC_DONE) { |
| mLogInfo.setMemo(LogInfo::CP_CB_SYNC_REV, _msgType); |
| } |
| MY_LOGD("P1 doNotifyCb(%d) %zd %zd %zd", _msgType, _ext1, _ext2, _ext3); |
| // |
| if (CC_UNLIKELY(!getActive())) { |
| MY_LOGI("not-active-return"); |
| if (_msgType == IHal3ACb::eID_NOTIFY_3APROC_FINISH) { |
| mLogInfo.setMemo(LogInfo::CP_CB_PROC_RET, _msgType, MTRUE); |
| } else if (_msgType == IHal3ACb::eID_NOTIFY_VSYNC_DONE) { |
| mLogInfo.setMemo(LogInfo::CP_CB_SYNC_RET, _msgType, MTRUE); |
| } |
| return; |
| } |
| switch (_msgType) { |
| case IHal3ACb::eID_NOTIFY_3APROC_FINISH: |
| if (_ext3 == 0) { |
| MY_LOGE("CapParam NULL (%d) %zd %zd", _msgType, _ext1, _ext2); |
| } else { |
| NS3Av3::RequestSet_T set = |
| *reinterpret_cast<NS3Av3::RequestSet_T*>(_ext1); |
| NS3Av3::CapParam_T param = |
| *reinterpret_cast<NS3Av3::CapParam_T*>(_ext3); |
| onSyncBegin(MFALSE, &set, (MUINT32)_ext2, ¶m); |
| } |
| mLogInfo.setMemo(LogInfo::CP_CB_PROC_RET, _msgType, MFALSE); |
| break; |
| case IHal3ACb::eID_NOTIFY_CURR_RESULT: |
| break; |
| case IHal3ACb::eID_NOTIFY_VSYNC_DONE: |
| onSyncEnd(); |
| mLogInfo.setMemo(LogInfo::CP_CB_SYNC_RET, _msgType, MFALSE); |
| break; |
| default: |
| break; |
| } |
| // |
| FUNCTION_OUT; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| void P1NodeImp::doNotifyDropframe(MUINT magicNum, void* cookie) { |
| MY_LOGI("notify drop frame (%d)", magicNum); |
| |
| if (cookie == nullptr) { |
| MY_LOGE("return cookie is NULL"); |
| return; |
| } |
| MINT32 mSysLevel = reinterpret_cast<P1NodeImp*>(cookie)->mSysLevel; |
| P1_TRACE_F_BEGIN(SLG_E, "P1:DRV-drop(%d)", magicNum); |
| |
| { |
| std::lock_guard<std::mutex> _l( |
| reinterpret_cast<P1NodeImp*>(cookie)->mDropQueueLock); |
| reinterpret_cast<P1NodeImp*>(cookie)->mDropQueue.push_back(magicNum); |
| MY_LOGI("[Cam::%d] receive drop frame (%d)", |
| reinterpret_cast<P1NodeImp*>(cookie)->getOpenId(), magicNum); |
| } |
| |
| if ((reinterpret_cast<P1NodeImp*>(cookie)->mpDeliverMgr != nullptr) && |
| (reinterpret_cast<P1NodeImp*>(cookie)->mpDeliverMgr->runningGet())) { |
| MY_LOGI("[Cam::%d] process drop frame (%d)", |
| reinterpret_cast<P1NodeImp*>(cookie)->getOpenId(), magicNum); |
| reinterpret_cast<P1NodeImp*>(cookie)->mpDeliverMgr->trigger(); |
| } |
| P1_TRACE_C_END(SLG_E); // "P1:DRV-drop" |
| } |
| |
| #if (USING_DRV_IO_PIPE_EVENT) |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| NSCam::NSIoPipe::IoPipeEventCtrl P1NodeImp::onEvtCtrlAcquiring( |
| P1NodeImp* user, NSCam::NSIoPipe::IpRawP1AcquiringEvent* evt) { |
| if (CC_UNLIKELY(user == nullptr)) { |
| MY_LOGW("user is NULL"); |
| (*evt).setResult((NSCam::NSIoPipe::IoPipeEvent::ResultType) |
| NSCam::NSIoPipe::IoPipeEvent::RESULT_ERROR); |
| return NSCam::NSIoPipe::IoPipeEventCtrl::STOP_BROADCASTING; |
| } |
| std::lock_guard<std::mutex> _l(user->mIoPipeEvtOpLock); |
| if (CC_UNLIKELY(user->mIoPipeEvtOpLeaving)) { |
| MY_LOGI("[Cam::%d] IoPipeEvtOpLeaving return", user->mOpenId); |
| return NSCam::NSIoPipe::IoPipeEventCtrl::OK; |
| } |
| if (CC_UNLIKELY(user->mIoPipeEvtOpAcquired == MTRUE)) { |
| MY_LOGI("[Cam::%d] IoPipeEvtOpAcquired:1 return", user->mOpenId); |
| (*evt).setResult((NSCam::NSIoPipe::IoPipeEvent::ResultType) |
| NSCam::NSIoPipe::IoPipeEvent::RESULT_REJECT); |
| return NSCam::NSIoPipe::IoPipeEventCtrl::STOP_BROADCASTING; |
| } |
| user->eventStreamingOff(); |
| user->mIoPipeEvtOpAcquired = MTRUE; |
| return NSCam::NSIoPipe::IoPipeEventCtrl::OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| NSCam::NSIoPipe::IoPipeEventCtrl P1NodeImp::onEvtCtrlReleasing( |
| P1NodeImp* user, NSCam::NSIoPipe::IpRawP1ReleasedEvent* evt) { |
| if (CC_UNLIKELY(user == nullptr)) { |
| MY_LOGW("user is NULL"); |
| (*evt).setResult((NSCam::NSIoPipe::IoPipeEvent::ResultType) |
| NSCam::NSIoPipe::IoPipeEvent::RESULT_ERROR); |
| return NSCam::NSIoPipe::IoPipeEventCtrl::STOP_BROADCASTING; |
| } |
| std::lock_guard<std::mutex> _l(user->mIoPipeEvtOpLock); |
| if (CC_UNLIKELY(user->mIoPipeEvtOpLeaving)) { |
| MY_LOGI("[Cam::%d] IoPipeEvtOpLeaving return", user->mOpenId); |
| return NSCam::NSIoPipe::IoPipeEventCtrl::OK; |
| } |
| if (CC_UNLIKELY(user->mIoPipeEvtOpAcquired == MFALSE)) { |
| MY_LOGI("[Cam::%d] IoPipeEvtOpAcquired:0 return", user->mOpenId); |
| (*evt).setResult((NSCam::NSIoPipe::IoPipeEvent::ResultType) |
| NSCam::NSIoPipe::IoPipeEvent::RESULT_REJECT); |
| return NSCam::NSIoPipe::IoPipeEventCtrl::STOP_BROADCASTING; |
| } |
| user->eventStreamingOn(); |
| user->mIoPipeEvtOpAcquired = MFALSE; |
| return NSCam::NSIoPipe::IoPipeEventCtrl::OK; |
| } |
| #endif |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::createStuffBuffer( |
| std::shared_ptr<IImageBuffer>* imageBuffer, |
| std::shared_ptr<IImageStreamInfo> const& streamInfo, |
| NSCam::MSize::value_type const changeHeight) { |
| std::vector<MUINT32> vStride; |
| vStride.clear(); |
| vStride.reserve(streamInfo->getBufPlanes().size()); |
| for (size_t i = 0; i < streamInfo->getBufPlanes().size(); i++) { |
| vStride.push_back( |
| (MUINT32)(streamInfo->getBufPlanes()[i].rowStrideInBytes)); |
| } |
| // |
| MSize size = streamInfo->getImgSize(); |
| // change the height while changeHeight > 0 |
| if (changeHeight > 0) { |
| size.h = changeHeight; |
| } |
| // |
| return createStuffBuffer(imageBuffer, streamInfo->getStreamName(), |
| streamInfo->getImgFormat(), size, vStride); |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::createStuffBuffer(std::shared_ptr<IImageBuffer>* imageBuffer, |
| char const* szName, |
| MINT32 format, |
| MSize size, |
| std::vector<MUINT32> vStride) { |
| return mStuffBufMgr.acquireStoreBuffer( |
| imageBuffer, szName, format, size, vStride, mBurstNum, |
| (mDebugScanLineMask != 0) ? MTRUE : MFALSE); |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::destroyStuffBuffer(std::shared_ptr<IImageBuffer>* imageBuffer) { |
| if (imageBuffer == nullptr) { |
| MY_LOGW("Stuff ImageBuffer not exist"); |
| return BAD_VALUE; |
| } |
| return mStuffBufMgr.releaseStoreBuffer(imageBuffer); |
| } |
| |
| #if (USING_DRV_IO_PIPE_EVENT) |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::eventStreamingInform() { |
| { |
| pthread_rwlock_rdlock(&mIoPipeEvtStateLock); |
| if (CC_LIKELY(mIoPipeEvtState != IO_PIPE_EVT_STATE_ACQUIRING)) { |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| return; |
| } |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| } |
| // |
| { |
| std::lock_guard<std::mutex> _l(mIoPipeEvtWaitLock); |
| if (CC_LIKELY(mIoPipeEvtWaiting)) { |
| if ((mpDeliverMgr != nullptr) && (mpDeliverMgr->runningGet()) && |
| (mpDeliverMgr->isActListEmpty())) { |
| mIoPipeEvtWaitCond.notify_all(); |
| MY_LOGI("action list is empty"); |
| } |
| } |
| } |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::eventStreamingOn() { |
| P1_TRACE_AUTO(SLG_E, "P1:eventStreamingOn"); |
| MY_LOGI("StreamingOn +"); |
| std::lock_guard<std::mutex> _l(mPublicLock); |
| { |
| pthread_rwlock_rdlock(&mIoPipeEvtStateLock); |
| if (CC_UNLIKELY(mIoPipeEvtState != IO_PIPE_EVT_STATE_ACQUIRED)) { |
| MY_LOGI("StreamingOn return - state(%d)", mIoPipeEvtState); |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| return; |
| } |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| } |
| { |
| pthread_rwlock_wrlock(&mIoPipeEvtStateLock); |
| mIoPipeEvtState = IO_PIPE_EVT_STATE_NONE; |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| } |
| // |
| beckonRequest(); |
| MY_LOGI("StreamingOn -"); |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::eventStreamingOff() { |
| P1_TRACE_AUTO(SLG_E, "P1:eventStreamingOff"); |
| MY_LOGI("StreamingOff +"); |
| std::lock_guard<std::mutex> _l(mPublicLock); |
| { |
| pthread_rwlock_rdlock(&mIoPipeEvtStateLock); |
| if (CC_UNLIKELY(mIoPipeEvtState != IO_PIPE_EVT_STATE_NONE)) { |
| MY_LOGI("StreamingOff return - state(%d)", mIoPipeEvtState); |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| return; |
| } |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| } |
| { |
| pthread_rwlock_wrlock(&mIoPipeEvtStateLock); |
| mIoPipeEvtState = IO_PIPE_EVT_STATE_ACQUIRING; |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| } |
| // |
| // wait for the last NORMAL/BYPASS action done |
| MBOOL bWaitDrain = MTRUE; |
| #if 1 |
| { |
| MINT32 nWaitDrain = |
| property_get_int32("vendor.debug.camera.log.p1nodefasthqc", 0); |
| if (nWaitDrain > 0) { |
| MY_LOGI("p1node-fast-hqc:%d", nWaitDrain); |
| bWaitDrain = MFALSE; |
| } |
| } |
| #endif |
| if (bWaitDrain && (mpDeliverMgr != nullptr) && (mpDeliverMgr->runningGet())) { |
| std::unique_lock<std::mutex> lck(mIoPipeEvtWaitLock); |
| mIoPipeEvtWaiting = MTRUE; |
| while (!mpDeliverMgr->isActListEmpty()) { |
| std::cv_status res = mIoPipeEvtWaitCond.wait_for( |
| lck, std::chrono::nanoseconds(P1NODE_EVT_DRAIN_WAIT_INV_NS)); |
| if (res != std::cv_status::timeout) { |
| MY_LOGI("all actions done"); |
| break; |
| } else { |
| MY_LOGI("actions not finish - res(%d) empty(%d)", res, |
| mpDeliverMgr->isActListEmpty()); |
| mpDeliverMgr->dumpInfo(); |
| mLogInfo.inspect(LogInfo::IT_EVT_WAIT_DRAIN_TIMEOUT); |
| } |
| } |
| mIoPipeEvtWaiting = MFALSE; |
| } else { |
| MY_LOGI("stop and flush directly, WaitDrain(%d)", bWaitDrain); |
| } |
| // In InitReq Flow (EN_INIT_REQ), mInitReqOff re-assign by eventStreamingOff() |
| // via onHandleFlush(). While eventStreamingOn(), by mInitReqOff to disable |
| // the init-request-flow as the next first request arrival. |
| onHandleFlush(MFALSE, MTRUE); // disable InitReq flow |
| // |
| { |
| pthread_rwlock_wrlock(&mIoPipeEvtStateLock); |
| mIoPipeEvtState = IO_PIPE_EVT_STATE_ACQUIRED; |
| pthread_rwlock_unlock(&mIoPipeEvtStateLock); |
| } |
| MY_LOGI("StreamingOff -"); |
| return; |
| } |
| #endif |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::hardwareOps_start() { |
| #if SUPPORT_ISP |
| FUNCTION_IN; |
| P1_TRACE_AUTO(SLG_B, "P1:hardwareOps_start"); |
| MERROR err = OK; |
| mLogInfo.setMemo(LogInfo::CP_OP_START_BGN, mBurstNum, mEnableCaptureFlow, |
| (EN_INIT_REQ_RUN) ? mInitReqSet : 0); |
| |
| std::lock_guard<std::mutex> _l(mHardwareLock); |
| |
| mTagReq.clear(); |
| mTagSet.clear(); |
| mTagEnq.clear(); |
| mTagDeq.clear(); |
| mTagOut.clear(); |
| mTagList.clear(); |
| |
| { |
| MINT64 currentTime = (MINT64)(NSCam::Utils::getTimeInNs()); |
| { |
| std::lock_guard<std::mutex> _l(mMonitorLock); |
| mMonitorTime = currentTime; |
| } |
| } |
| |
| { |
| std::lock_guard<std::mutex> _l(mThreadLock); |
| setActive(MTRUE); |
| mThreadCond.notify_all(); |
| } |
| setStartState(NSP1Node::START_STATE_NULL); |
| #if USING_CTRL_3A_LIST_PREVIOUS |
| mPreviousCtrlList.clear(); |
| #endif |
| setInit(MTRUE); |
| mLastSofIdx = P1SOFIDX_NULL_VAL; |
| mLastSetNum = 0; |
| { |
| std::lock_guard<std::mutex> _ll(mTransferJobLock); |
| mTransferJobIdx = P1ACT_ID_NULL; |
| mTransferJobWaiting = MFALSE; |
| } |
| |
| mConfigPort = CONFIG_PORT_NONE; |
| mConfigPortNum = 0; |
| |
| mFirstReceived = MFALSE; |
| // |
| { |
| std::lock_guard<std::mutex> _ll(mFrameSetLock); |
| mFrameSetAlready = MFALSE; |
| } |
| // |
| mDequeThreadProfile.reset(); |
| // |
| EImageFormat resizer_fmt = eImgFmt_FG_BAYER10; |
| // |
| if (mspResConCtrl != nullptr) { |
| P1NODE_RES_CON_ACQUIRE(mspResConCtrl, mResConClient, mIsResConGot); |
| } |
| // |
| { |
| EPipeSelect ps = EPipeSelect_Normal; |
| if (mPipeMode == PIPE_MODE_NORMAL_SV) { |
| ps = EPipeSelect_NormalSv; |
| } |
| |
| int selectedVersion = 0; |
| const unsigned int* version = nullptr; |
| size_t count = 0; |
| err = getNormalPipeModule()->get_sub_module_api_version(&version, &count); |
| if (err < 0 || !count || !version) { |
| MY_LOGE( |
| "[%d] INormalPipeModule::get_sub_module_api_version - err:%#x " |
| "count:%zu version:%p", |
| getOpenId(), err, count, version); |
| } else { |
| selectedVersion = *(version + count - 1); // Select max. version |
| } |
| |
| MY_LOGI("[%d] count:%zu Selected CamIO Version:%0#x", getOpenId(), count, |
| selectedVersion); |
| |
| mpCamIO = getNormalPipeModule()->getSubModule( |
| kPipeNormal, getOpenId(), getNodeName(), selectedVersion); |
| |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_START_DRV_INIT_BGN, |
| LogInfo::CP_OP_START_DRV_INIT_END); |
| } |
| |
| #if SUPPORT_LCS |
| err = lcsInit(); |
| if (err != OK) { |
| MY_LOGE("lcsInit fail"); |
| return err; |
| } |
| #endif |
| MSize sensorSize = mSensorParams.size; |
| MSize rrzoSize = mvStreamImg[STREAM_IMG_OUT_RESIZE]->getImgSize(); |
| err = lmvInit(sensorSize, rrzoSize); |
| if (err != OK) { |
| MY_LOGE("lmvInit fail"); |
| return err; |
| } |
| |
| MUINT32 AETargetMode = MFALSE; // vHDR OFF mode |
| NS3Av3::AEInitExpoSetting_T initExpoSetting; |
| ::memset(&initExpoSetting, 0, sizeof(initExpoSetting)); |
| initExpoSetting.u4SensorMode = mSensorParams.mode; |
| initExpoSetting.u4AETargetMode = AETargetMode; |
| // set shutter/gain 0 as ::memset |
| #if SUPPORT_3A |
| err = getAEInitExpoSetting(&initExpoSetting); |
| if (err != OK) { |
| MY_LOGE("getAEInitExpoSetting fail"); |
| return err; |
| } |
| #endif |
| |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| v4l2DeviceStart(); |
| #endif |
| // |
| PipeTag pipe_tag = kPipeTag_Out2_Tuning; |
| std::vector<PortInfo> vPortInfo; |
| vPortInfo.clear(); |
| vPortInfo.reserve(P1_OUTPUT_PORT_TOTAL); |
| addConfigPort(&vPortInfo, &resizer_fmt); |
| // |
| IHalSensor::ConfigParam sensorCfg; |
| ::memset(&sensorCfg, 0, sizeof(IHalSensor::ConfigParam)); |
| QInitParam halCamIOinitParam = |
| prepareQInitParam(&sensorCfg, initExpoSetting, vPortInfo); |
| // |
| MSize binInfoSize = mSensorParams.size; |
| setCurrentBinSize(mSensorParams.size); |
| mIsBinEn = false; |
| MSize rawSize[2]; |
| MSize* pSizeProc = &rawSize[0]; // 0 = EPipe_PROCESSED_RAW |
| MSize* pSizePure = &rawSize[1]; // 1 = EPipe_PURE_RAW |
| *pSizeProc = MSize(0, 0); |
| *pSizePure = MSize(0, 0); |
| |
| std::map<int, std::vector<std::shared_ptr<IImageBuffer>>> buffers; |
| err = |
| startCamIO(halCamIOinitParam, &binInfoSize, rawSize, &pipe_tag, &buffers); |
| if (err != OK) { |
| MY_LOGE("startCamIO fail"); |
| return err; |
| } |
| |
| if (auto pModule = getNormalPipeModule()) { |
| #if 1 // query height ratio from DRV |
| NormalPipe_QueryInfo info; |
| pModule->query(PORT_RRZO.index, ENPipeQueryCmd_BS_RATIO, resizer_fmt, 0, |
| &info); |
| mResizeRatioMax = info.bs_ratio; |
| MY_LOGI("ResizeRatioMax = info.bs_ratio(%d)", info.bs_ratio); |
| #endif |
| } |
| |
| #if SUPPORT_3A |
| { |
| P1_TIMING_CHECK("P1:3A-notifyPwrOn", 10, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-notifyPwrOn"); |
| mLogInfo.setMemo(LogInfo::CP_OP_START_3A_PWRON_BGN); |
| if (mp3A->notifyP1PwrOn()) { // CCU DRV power on after ISP configPipe |
| setPowerNotify(MTRUE); |
| } else { |
| MY_LOGI("3A->notifyP1PwrOn() return FALSE"); |
| } |
| mLogInfo.setMemo(LogInfo::CP_OP_START_3A_PWRON_END); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-notifyPwrOn" |
| } |
| { |
| P1_TIMING_CHECK("P1:3A-setSensorMode", 10, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-setSensorMode"); |
| mp3A->setSensorMode(mSensorParams.mode); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-setSensorMode" |
| } |
| #endif |
| if (IS_LMV(mpConnectLMV)) { |
| P1_TIMING_CHECK("P1:LMV-config", 20, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:LMV-config"); |
| MY_LOGD("mpConnectLMV->config"); |
| mpConnectLMV->config(buffers[PORT_EISO.index]); |
| P1_TRACE_C_END(SLG_S); // "P1:LMV-config" |
| } |
| |
| #if SUPPORT_LCS |
| if (mpLCS) { |
| LCS_HAL_CONFIG_DATA lcsConfig; |
| lcsConfig.cameraVer = LCS_CAMERA_VER_3; |
| if (mvStreamImg[STREAM_IMG_OUT_LCS] != nullptr) { |
| lcsConfig.lcsOutWidth = mvStreamImg[STREAM_IMG_OUT_LCS]->getImgSize().w; |
| lcsConfig.lcsOutHeight = mvStreamImg[STREAM_IMG_OUT_LCS]->getImgSize().h; |
| lcsConfig.tgWidth = mSensorParams.size.w; |
| lcsConfig.tgHeight = mSensorParams.size.h; |
| } else { |
| MY_LOGI("LCS enable but no LCS stream info"); |
| lcsConfig.lcsOutWidth = 0; |
| lcsConfig.lcsOutHeight = 0; |
| } |
| // |
| P1_TIMING_CHECK("P1:LCS-config", 20, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:LCS-config"); |
| mpLCS->ConfigLcsHal(lcsConfig); |
| P1_TRACE_C_END(SLG_S); // "P1:LCS-config" |
| } |
| #endif |
| |
| if (mpConCtrl != nullptr && mpConCtrl->getStageCtrl() != nullptr) { |
| mpConCtrl->getStageCtrl()->done((MUINT32)STAGE_DONE_START, MTRUE); |
| } |
| |
| #if SUPPORT_3A |
| if (mp3A) { |
| P1_TIMING_CHECK("P1:3A-config", 300, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-sendCtrl-attachCb"); |
| mp3A->attachCb(IHal3ACb::eID_NOTIFY_3APROC_FINISH, this); |
| mp3A->attachCb(IHal3ACb::eID_NOTIFY_CURR_RESULT, this); |
| mp3A->attachCb(IHal3ACb::eID_NOTIFY_VSYNC_DONE, this); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-sendCtrl-attachCb" |
| NS3Av3::ConfigInfo_T config; |
| NS3Av3::EBitMode_T b = NS3Av3::EBitMode_12Bit; |
| switch (mPipeBit) { |
| case CAM_Pipeline_10BITS: |
| b = NS3Av3::EBitMode_10Bit; |
| break; |
| case CAM_Pipeline_12BITS: |
| b = NS3Av3::EBitMode_12Bit; |
| break; |
| case CAM_Pipeline_14BITS: |
| b = NS3Av3::EBitMode_14Bit; |
| break; |
| case CAM_Pipeline_16BITS: |
| b = NS3Av3::EBitMode_16Bit; |
| break; |
| default: |
| MY_LOGW("CANNOT map the pipeline bit mode"); |
| break; |
| } |
| config.i4BitMode = b; |
| config.i4SubsampleCount = (MINT32)(MAX(mBurstNum, 1)); |
| config.i4HlrOption = (mDisableHLR) ? (NS3Av3::EHlrOption_ForceOff) |
| : (NS3Av3::EHlrOption_Auto); |
| config.CfgAppMeta = mCfgAppMeta; |
| config.CfgHalMeta = mCfgHalMeta; |
| // |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_START_3A_CFG_BGN, |
| LogInfo::CP_OP_START_3A_CFG_END); |
| |
| /* getMatrix to active and from active here */ |
| NSCamHW::HwTransHelper helper(getOpenId()); |
| NSCamHW::HwMatrix matFromActive; |
| if (!helper.getMatrixFromActive(mSensorParams.mode, &matFromActive)) |
| MY_LOGE("Get hw matFromActive failed"); |
| NSCamHW::HwMatrix matToActive; |
| if (!helper.getMatrixToActive(mSensorParams.mode, &matToActive)) |
| MY_LOGE("Get hw matToActive failed"); |
| config.matFromAct = matFromActive; |
| config.matToAct = matToActive; |
| |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| /* update static metadata for sandbox */ |
| std::shared_ptr<IMetadataProvider> pMetadataProvider = |
| NSMetadataProviderManager::valueFor(getOpenId()); |
| if (pMetadataProvider.get()) { |
| const IMetadata& metaStaticInfo = |
| pMetadataProvider->getMtkStaticCharacteristics(); |
| NS3Av3::IpcMetaStaticInfo_T ipcMetaStaticInfo; |
| |
| const IMetadata::IEntry& entryAvailableScene = |
| metaStaticInfo.entryFor(MTK_CONTROL_AVAILABLE_SCENE_MODES); |
| ipcMetaStaticInfo.availableSceneModesCount = entryAvailableScene.count(); |
| for (int i = 0; i < entryAvailableScene.count(); i++) |
| ipcMetaStaticInfo.availableSceneModes[i] = |
| entryAvailableScene.itemAt(i, Type2Type<MUINT8>()); |
| |
| const IMetadata::IEntry& entryScnOvrd = |
| metaStaticInfo.entryFor(MTK_CONTROL_SCENE_MODE_OVERRIDES); |
| ipcMetaStaticInfo.sceneModeOverridesCount = entryScnOvrd.count(); |
| for (int i = 0; i < entryScnOvrd.count(); i++) |
| ipcMetaStaticInfo.sceneModeOverrides[i] = |
| entryScnOvrd.itemAt(i, Type2Type<MUINT8>()); |
| |
| NS3Av3::QUERY_ENTRY_SINGLE(metaStaticInfo, |
| MTK_CONTROL_AE_COMPENSATION_STEP, |
| &ipcMetaStaticInfo.aeCompensationStep); |
| NS3Av3::GET_ENTRY_ARRAY(metaStaticInfo, MTK_CONTROL_MAX_REGIONS, |
| ipcMetaStaticInfo.maxRegions, 3); |
| NS3Av3::QUERY_ENTRY_SINGLE(metaStaticInfo, |
| MTK_SENSOR_INFO_ACTIVE_ARRAY_REGION, |
| &ipcMetaStaticInfo.activeArrayRegion); |
| NS3Av3::QUERY_ENTRY_SINGLE(metaStaticInfo, MTK_LENS_INFO_SHADING_MAP_SIZE, |
| &ipcMetaStaticInfo.shadingMapSize); |
| NS3Av3::QUERY_ENTRY_SINGLE(metaStaticInfo, |
| MTK_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, |
| &ipcMetaStaticInfo.availableFocalLengths); |
| NS3Av3::QUERY_ENTRY_SINGLE(metaStaticInfo, |
| MTK_LENS_INFO_AVAILABLE_APERTURES, |
| &ipcMetaStaticInfo.availableApertures); |
| |
| mp3A->send3ACtrl(NS3Av3::E3ACtrl_IPC_Set_MetaStaticInfo, |
| reinterpret_cast<MINTPTR>(&ipcMetaStaticInfo), 0); |
| } |
| #endif |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-config"); |
| MY_LOGI("mp3A->config +++"); |
| mp3A->config(config); |
| MY_LOGI("mp3A->config ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-config" |
| } |
| #endif |
| // |
| if (mpHwStateCtrl != nullptr) { |
| MBOOL isLegacy = |
| (mIsLegacyStandbyMode || mForceStandbyMode > 0) ? MTRUE : MFALSE; |
| mpHwStateCtrl->config(getOpenId(), mLogLevel, mLogLevelI, mSysLevel, |
| mBurstNum, mpCamIO.get(), mp3A, isLegacy); |
| } |
| // |
| #ifdef P1_START_INFO_STR |
| #undef P1_START_INFO_STR |
| #endif |
| #define P1_START_INFO_STR \ |
| "Cam::%d " \ |
| "Sensor(%dx%d) Raw(%d,0x%x)-Proc(%dx%d)-Pure(%dx%d) " \ |
| "Bin(%dx%d) BinEn=%d TG(%d:%d) DTwin(%d@%d)=%d LSM(%d) QLV(%d) " \ |
| "Ratio(%d) SensorCfg(i:%d %dx%d s:%d b:%d c:%d, h:%d f:%d t:%d d:%d) " \ |
| "ConfigPort[%d]:(0x%x) InitParam[R:%d B:%d D:%d Nd:%d )]" |
| |
| #ifdef P1_START_INFO_VAR |
| #undef P1_START_INFO_VAR |
| #endif |
| #define P1_START_INFO_VAR \ |
| getOpenId(), mSensorParams.size.w, mSensorParams.size.h, mRawDefType, \ |
| mRawOption, pSizeProc->w, pSizeProc->h, pSizePure->w, pSizePure->h, \ |
| binInfoSize.w, binInfoSize.h, mIsBinEn, mTgNum, mCfg.mSensorNum, \ |
| mDisableDynamicTwin, mCfg.mSupportDynamicTwin, mIsDynamicTwinEn, \ |
| mIsLegacyStandbyMode, mCfg.mQualityLv, mResizeRatioMax, sensorCfg.index, \ |
| sensorCfg.crop.w, sensorCfg.crop.h, sensorCfg.scenarioId, \ |
| sensorCfg.isBypassScenario, sensorCfg.isContinuous, sensorCfg.HDRMode, \ |
| sensorCfg.framerate, sensorCfg.twopixelOn, sensorCfg.debugMode, \ |
| mConfigPortNum, mConfigPort, halCamIOinitParam.mRawType, \ |
| halCamIOinitParam.m_pipelinebitdepth, halCamIOinitParam.m_DynamicTwin, \ |
| halCamIOinitParam.m_IQlv |
| // |
| if (EN_INIT_REQ_RUN) { |
| MY_LOGI("InitRqeFlow return %d %d %d - " P1_START_INFO_STR, mInitReqSet, |
| mInitReqNum, mInitReqCnt, P1_START_INFO_VAR); |
| mLogInfo.setMemo(LogInfo::CP_OP_START_REQ_WAIT_BGN, |
| LogInfo::START_SET_REQUEST); |
| return OK; |
| } |
| // |
| if (EN_START_CAP) { |
| std::lock_guard<std::mutex> _l(mStartCaptureLock); |
| mStartCaptureState = START_CAP_STATE_WAIT_REQ; |
| mStartCaptureType = NS3Av3::E_CAPTURE_NORMAL; |
| mStartCaptureIdx = 0; |
| mStartCaptureExp = 0; |
| MY_LOGI("EnableCaptureFlow(%d) return - " P1_START_INFO_STR, |
| mEnableCaptureFlow, P1_START_INFO_VAR); |
| mLogInfo.setMemo(LogInfo::CP_OP_START_REQ_WAIT_BGN, |
| LogInfo::START_SET_CAPTURE); |
| return OK; |
| } |
| |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| |
| { |
| MY_LOGI("V4L2TuningPipeMgr start +++"); |
| mpV4L2TuningPipe = |
| std::make_shared<v4l2::V4L2TuningPipeMgr>(pipe_tag, getOpenId()); |
| mpV4L2TuningPipe->startWorker(); |
| MY_LOGI("V4L2TuningPipeMgr start ---"); |
| // stt pipe should be started after normalpipe started. |
| |
| MY_LOGI("V4L2SttPipeMgr start +++"); |
| |
| // checks if need META2 or not |
| const int enableMeta2 = [&]() { |
| if (mpV4L2LensMgr == nullptr) { |
| return v4l2::V4L2SttPipeMgr::DISABLE_META2; |
| } |
| return mpV4L2LensMgr->isLensDriverOpened() |
| ? v4l2::V4L2SttPipeMgr::ENABLE_META2 |
| : v4l2::V4L2SttPipeMgr::DISABLE_META2; |
| }(); |
| |
| mpV4L2SttPipe = std::make_shared<v4l2::V4L2SttPipeMgr>( |
| pipe_tag, getOpenId(), enableMeta2); |
| |
| mpV4L2SttPipe->start(); |
| MY_LOGI("V4L2SttPipeMgr start ---"); |
| |
| // HWEvent workers |
| // Notice: HwEventWorkers must be started after INormalPipe started. |
| MY_LOGI("V4L2HwEventWorker start +++"); |
| auto _create_hw_event_mgrs = [this](size_t idx, EPipeSignal signal, |
| const char* caller) { |
| mpV4L2HwEventMgr[idx] = std::make_shared<v4l2::V4L2HwEventWorker>( |
| getOpenId(), signal, caller); |
| |
| mpV4L2HwEventMgr[idx]->start(); |
| }; |
| MY_LOGI("V4L2HwEventWorker start ---"); |
| _create_hw_event_mgrs(0, EPipeSignal_SOF, "evtmgr_sof"); |
| _create_hw_event_mgrs(1, EPipeSignal_AFDONE, "evtmgr_afdone"); |
| _create_hw_event_mgrs(2, EPipeSignal_EOF, "evtmgr_eof"); |
| } |
| #endif |
| |
| #if SUPPORT_3A |
| if (mp3A) { |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_START_3A_START_BGN, |
| LogInfo::CP_OP_START_3A_START_END); |
| P1_TIMING_CHECK("P1:3A-start", 100, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-start"); |
| MY_LOGI("mp3A->start +++"); |
| mp3A->start(); |
| MY_LOGI("mp3A->start ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-start" |
| } |
| #endif |
| |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| { |
| /* wait until a buffer enqueued, and stream on tuning pipe */ |
| CAM_LOGD("V4L2TuningPipeMgr: wait until enqued [+]"); |
| mpV4L2TuningPipe->waitUntilEnqued(); |
| CAM_LOGD("V4L2TuningPipeMgr: wait until enqued [-]"); |
| mpV4L2TuningPipe->startPipe(); |
| } |
| #endif |
| |
| // |
| { |
| if (mpConCtrl != nullptr && mpConCtrl->getStageCtrl() != nullptr) { |
| MBOOL success = MFALSE; |
| mpConCtrl->getStageCtrl()->wait((MUINT32)STAGE_DONE_INIT_ITEM, &success); |
| if (!success) { |
| MY_LOGE("stage - init item fail"); |
| return BAD_VALUE; |
| } |
| } |
| // |
| MERROR status = hardwareOps_enque( |
| &mProcessingQueue.at(mProcessingQueue.size() - 1), ENQ_TYPE_INITIAL); |
| if (status != OK) { |
| MY_LOGE("hardware init-enque fail (%d)", status); |
| return status; |
| } |
| } |
| // |
| if (mpConCtrl != nullptr) { |
| mpConCtrl->cleanAidStage(); |
| } |
| // |
| setStartState(NSP1Node::START_STATE_DRV_START); |
| if (mpCamIO != nullptr) { |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_START_DRV_START_BGN, |
| LogInfo::CP_OP_START_DRV_START_END); |
| P1_TIMING_CHECK("P1:DRV-start", 100, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-start"); |
| MY_LOGI("mpCamIO->start +++"); |
| if (!mpCamIO->start()) { |
| MY_LOGE("mpCamIO->start fail"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-start" |
| return BAD_VALUE; |
| } |
| MY_LOGI("mpCamIO->start ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-start" |
| } |
| setStartState(NSP1Node::START_STATE_LMV_SENSOR_EN); |
| if (IS_LMV(mpConnectLMV)) { |
| P1_TIMING_CHECK("P1:LMV-sensor", 100, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:LMV-sensor"); |
| MY_LOGD("mpConnectLMV->enableSensor +++"); |
| mpConnectLMV->enableSensor(); |
| MY_LOGD("mpConnectLMV->enableSensor ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:LMV-sensor" |
| } |
| { |
| std::lock_guard<std::mutex> _l(mThreadLock); |
| setReady(MTRUE); |
| mThreadCond.notify_all(); |
| } |
| { |
| std::lock_guard<std::mutex> _l(mStartLock); |
| setStartState(NSP1Node::START_STATE_READY); |
| mStartCond.notify_all(); |
| } |
| syncHelperStart(); |
| MY_LOGI("End - " P1_START_INFO_STR, P1_START_INFO_VAR); |
| #undef P1_START_INFO_STR |
| #undef P1_START_INFO_VAR |
| |
| mLogInfo.setMemo(LogInfo::CP_OP_START_END, mBurstNum, mEnableCaptureFlow, |
| mInitReqSet, LogInfo::START_SET_GENERAL); |
| |
| FUNCTION_OUT; |
| |
| return OK; |
| #else |
| return OK; |
| #endif |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::hardwareOps_request() { |
| #if SUPPORT_ISP |
| FUNCTION_IN; |
| P1_TRACE_AUTO(SLG_B, "P1:hardwareOps_request"); |
| // |
| mLogInfo.setMemo(LogInfo::CP_OP_START_REQ_WAIT_END, |
| LogInfo::START_SET_REQUEST); |
| // |
| std::lock_guard<std::mutex> _l(mHardwareLock); |
| // |
| #if USING_CTRL_3A_LIST |
| List<NS3Av3::MetaSet_T> ctrlList; |
| #else |
| std::vector<NS3Av3::MetaSet_T*> ctrlQueue; |
| ctrlQueue.clear(); |
| ctrlQueue.reserve(mInitReqNum); |
| #endif |
| // |
| MUINT32 total = mpTaskCollector->remainder(); |
| MUINT32 initNum = mInitReqNum - 1; |
| if (CC_UNLIKELY(total < mInitReqNum)) { |
| MY_LOGE("init request set is not enough (%d < %d)", total, mInitReqSet); |
| return BAD_VALUE; |
| } |
| // Prepare for DRV |
| for (MUINT32 index = 0; index < initNum; index++) { |
| P1QueJob job(mBurstNum); |
| mpTaskCtrl->sessionLock(); |
| mpTaskCollector->requireJob(&job); |
| mpTaskCtrl->sessionUnLock(); |
| { |
| std::lock_guard<std::mutex> _l(mProcessingQueueLock); |
| mProcessingQueue.push_back(job); |
| } |
| if (job.size() > 0 && job.edit(0).ptr() != nullptr) { |
| #if USING_CTRL_3A_LIST |
| ctrlList.push_back(job.edit(0).ptr()->metaSet); |
| #else |
| ctrlQueue.push_back(&(job.edit(0).ptr()->metaSet)); |
| #endif |
| } |
| } |
| // Set to 3A |
| { |
| P1QueJob job(mBurstNum); |
| mpTaskCtrl->sessionLock(); |
| mpTaskCollector->requireJob(&job); |
| mpTaskCtrl->sessionUnLock(); |
| { |
| std::lock_guard<std::mutex> _l(mRequestQueueLock); |
| mRequestQueue.push_back(job); |
| } |
| if (job.size() > 0 && job.edit(0).ptr() != nullptr) { |
| #if USING_CTRL_3A_LIST |
| ctrlList.push_back(job.edit(0).ptr()->metaSet); |
| #else |
| ctrlQueue.push_back(&(job.edit(0).ptr()->metaSet)); |
| #endif |
| } |
| mLastSetNum = job.getLastNum(); |
| mTagSet.set(mLastSetNum); |
| // |
| { |
| std::lock_guard<std::mutex> _ll(mFrameSetLock); |
| #if SUPPORT_3A |
| if (mp3A) { |
| P1_TIMING_CHECK("P1:3A-startRequest", 200, TC_W); |
| mLogInfo.setMemo(LogInfo::CP_START_SET_BGN, LogInfo::START_SET_REQUEST, |
| mLastSetNum); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-startRequest"); |
| MY_LOGI("mp3A->startRequestQ +++"); |
| #if USING_CTRL_3A_LIST |
| mp3A->startRequestQ(ctrlList); // mp3A->start(); |
| #else |
| mp3A->startRequestQ(ctrlQueue); // mp3A->start(); |
| #endif |
| MY_LOGI("mp3A->startRequestQ ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-startRequest" |
| mLogInfo.setMemo(LogInfo::CP_START_SET_END, LogInfo::START_SET_REQUEST, |
| mLastSetNum); |
| } |
| #endif |
| mFrameSetAlready = MTRUE; |
| } |
| } |
| // EnQ to DRV |
| { |
| for (MUINT32 idx = 0; idx < initNum; idx++) { |
| P1QueJob job; |
| { |
| // clone the QueJob from the ProcessingQueue |
| std::lock_guard<std::mutex> _l(mProcessingQueueLock); |
| job = mProcessingQueue.at(idx); |
| } |
| MY_LOGD("InitReqEnQ (%d/%d) +++", idx, initNum); |
| MERROR status = hardwareOps_enque(&job, ENQ_TYPE_INITIAL); |
| if (status != OK) { |
| MY_LOGE("hardware req-init-enque fail (%d)@(%d)", status, idx); |
| return status; |
| } |
| MY_LOGD("InitReqEnQ (%d/%d) ---", idx, initNum); |
| } |
| } |
| // |
| if (mpConCtrl != nullptr) { |
| mpConCtrl->cleanAidStage(); |
| } |
| // |
| setStartState(NSP1Node::START_STATE_DRV_START); |
| #if 1 |
| if (mpCamIO) { |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_START_DRV_START_BGN, |
| LogInfo::CP_OP_START_DRV_START_END); |
| P1_TIMING_CHECK("P1:DRV-start", 100, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-start"); |
| MY_LOGI("mpCamIO->start +++"); |
| if (!mpCamIO->start()) { |
| MY_LOGE("hardware start fail"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-start" |
| return BAD_VALUE; |
| } |
| MY_LOGI("mpCamIO->start ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-start" |
| } |
| #endif |
| setStartState(NSP1Node::START_STATE_LMV_SENSOR_EN); |
| if (IS_LMV(mpConnectLMV)) { |
| P1_TIMING_CHECK("P1:LMV-sensor", 100, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:LMV-sensor"); |
| MY_LOGD("mpConnectLMV->enableSensor +++"); |
| mpConnectLMV->enableSensor(); |
| MY_LOGD("mpConnectLMV->enableSensor ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:LMV-sensor" |
| } |
| { |
| std::lock_guard<std::mutex> _l(mThreadLock); |
| setReady(MTRUE); |
| mThreadCond.notify_all(); |
| } |
| { |
| std::lock_guard<std::mutex> _l(mStartLock); |
| setStartState(NSP1Node::START_STATE_READY); |
| mStartCond.notify_all(); |
| } |
| syncHelperStart(); |
| MY_LOGI("Cam::%d BinEn:%d ConfigPort[%d]:0x%x", getOpenId(), mIsBinEn, |
| mConfigPortNum, mConfigPort); |
| |
| mLogInfo.setMemo(LogInfo::CP_OP_START_END, mBurstNum, mEnableCaptureFlow, |
| mInitReqSet, LogInfo::START_SET_REQUEST); |
| |
| FUNCTION_OUT; |
| |
| return OK; |
| #else |
| return OK; |
| #endif |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::hardwareOps_capture() { |
| #if SUPPORT_ISP |
| FUNCTION_IN; |
| P1_TRACE_AUTO(SLG_B, "P1:hardwareOps_capture"); |
| // |
| mLogInfo.setMemo(LogInfo::CP_OP_START_REQ_WAIT_END, |
| LogInfo::START_SET_CAPTURE); |
| // |
| std::lock_guard<std::mutex> _l(mHardwareLock); |
| // |
| MINT32 num = 0; |
| MBOOL isManualCap = MFALSE; |
| // |
| if (EN_START_CAP) { |
| std::lock_guard<std::mutex> _l(mStartCaptureLock); |
| mStartCaptureState = START_CAP_STATE_WAIT_CB; |
| } |
| // |
| { |
| MINT32 type = NS3Av3::ESTART_CAP_NORMAL; |
| { |
| #if 1 |
| P1QueJob job(mBurstNum); |
| mpTaskCtrl->sessionLock(); |
| mpTaskCollector->requireJob(&job); |
| mpTaskCtrl->sessionUnLock(); |
| #endif |
| #if USING_CTRL_3A_LIST |
| List<NS3Av3::MetaSet_T> ctrlList; |
| generateCtrlList(&ctrlList, &job); |
| #else |
| std::vector<NS3Av3::MetaSet_T*> ctrlQueue; |
| ctrlQueue.clear(); |
| ctrlQueue.reserve(job.size()); |
| generateCtrlQueue(&ctrlQueue, &job); |
| #endif |
| { |
| std::lock_guard<std::mutex> _l(mRequestQueueLock); |
| mRequestQueue.push_back(job); |
| } |
| std::lock_guard<std::mutex> _ll(mFrameSetLock); |
| #if SUPPORT_3A |
| if (mp3A) { |
| P1_TIMING_CHECK("P1:3A-startCapture", 200, TC_W); |
| mLogInfo.setMemo(LogInfo::CP_START_SET_BGN, LogInfo::START_SET_CAPTURE, |
| job.getIdx()); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-startCapture"); |
| MY_LOGI("mp3A->startCapture +++"); |
| #if USING_CTRL_3A_LIST |
| type = mp3A->startCapture(ctrlList); // mp3A->start(); |
| #else |
| type = mp3A->startCapture(ctrlQueue); // mp3A->start(); |
| #endif |
| MY_LOGI("mp3A->startCapture ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-startCapture" |
| mLogInfo.setMemo(LogInfo::CP_START_SET_END, LogInfo::START_SET_CAPTURE, |
| job.getIdx()); |
| } |
| #endif |
| mFrameSetAlready = MTRUE; |
| MY_LOGI("start-capture-type %d", type); |
| } |
| if (type != NS3Av3::ESTART_CAP_NORMAL) { |
| isManualCap = MTRUE; |
| MY_LOGI("capture in manual flow %d", type); |
| } |
| } |
| // |
| if (mpConCtrl != nullptr && mpConCtrl->getStageCtrl() != nullptr) { |
| MBOOL success = MFALSE; |
| mpConCtrl->getStageCtrl()->wait((MUINT32)STAGE_DONE_INIT_ITEM, &success); |
| if (!success) { |
| MY_LOGE("stage - cap init item fail"); |
| return BAD_VALUE; |
| } |
| } |
| // |
| { |
| MERROR status = hardwareOps_enque( |
| &mProcessingQueue.at(mProcessingQueue.size() - 1), ENQ_TYPE_INITIAL); |
| if (status != OK) { |
| MY_LOGE("hardware cap-init-enque fail (%d)", status); |
| return status; |
| } |
| } |
| // |
| if (!isManualCap) { |
| P1_TRACE_S_BEGIN(SLG_S, "Cap Normal EnQ"); |
| P1QueJob job(mBurstNum); |
| { |
| { |
| std::lock_guard<std::mutex> _l(mRequestQueueLock); |
| if (CC_LIKELY(mRequestQueue.size() > 0)) { |
| Que_T::iterator it = mRequestQueue.begin(); |
| job = *it; |
| mRequestQueue.erase(it); |
| } else { |
| MY_LOGE("NormalCap RequestQueue is empty"); |
| return BAD_VALUE; |
| } |
| } |
| MERROR status = onProcessEnqueFrame(&job); |
| if (status != OK) { |
| MY_LOGE("hardware cap-enque-normal fail (%d)", status); |
| return status; |
| } |
| num = job.edit(0).getNum(); |
| } |
| P1_TRACE_C_END(SLG_S); // "Cap Normal EnQ" |
| // |
| if (num > 0) { |
| mLastSetNum = job.getLastNum(); |
| mTagSet.set(mLastSetNum); |
| } |
| } |
| // |
| if (mpConCtrl != nullptr) { |
| mpConCtrl->cleanAidStage(); |
| } |
| // |
| setStartState(NSP1Node::START_STATE_DRV_START); |
| #if 1 |
| if (mpCamIO) { |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_START_DRV_START_BGN, |
| LogInfo::CP_OP_START_DRV_START_END); |
| P1_TIMING_CHECK("P1:DRV-start", 100, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-start"); |
| MY_LOGI("mpCamIO->start +++"); |
| if (!mpCamIO->start()) { |
| MY_LOGE("hardware start fail"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-start" |
| return BAD_VALUE; |
| } |
| MY_LOGI("mpCamIO->start ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-start" |
| } |
| #endif |
| // |
| if (isManualCap) { |
| setStartState(NSP1Node::START_STATE_CAP_MANUAL_ENQ); |
| P1_TRACE_S_BEGIN(SLG_S, "Cap Manual EnQ"); |
| P1QueJob job(mBurstNum); |
| { |
| { |
| std::lock_guard<std::mutex> _l(mRequestQueueLock); |
| if (CC_LIKELY(mRequestQueue.size() > 0)) { |
| Que_T::iterator it = mRequestQueue.begin(); |
| job = *it; |
| mRequestQueue.erase(it); |
| } else { |
| MY_LOGE("ManualCap RequestQueue is empty"); |
| return BAD_VALUE; |
| } |
| } |
| MERROR status = onProcessEnqueFrame(&job); |
| if (status != OK) { |
| MY_LOGE("hardware cap-enque-manual fail (%d)", status); |
| return status; |
| } |
| num = job.edit(0).getNum(); |
| } |
| P1_TRACE_C_END(SLG_S); // "Cap Manual EnQ" |
| // |
| if (num > 0) { |
| mLastSetNum = job.getLastNum(); |
| mTagSet.set(mLastSetNum); |
| } |
| } |
| setStartState(NSP1Node::START_STATE_LMV_SENSOR_EN); |
| if (IS_LMV(mpConnectLMV)) { |
| P1_TIMING_CHECK("P1:LMV-sensor", 100, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:LMV-sensor"); |
| MY_LOGD("mpConnectLMV->enableSensor +++"); |
| mpConnectLMV->enableSensor(); |
| MY_LOGD("mpConnectLMV->enableSensor ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:LMV-sensor" |
| } |
| { |
| std::lock_guard<std::mutex> _l(mThreadLock); |
| setReady(MTRUE); |
| mThreadCond.notify_all(); |
| } |
| { |
| std::lock_guard<std::mutex> _l(mStartLock); |
| setStartState(NSP1Node::START_STATE_READY); |
| mStartCond.notify_all(); |
| } |
| syncHelperStart(); |
| MY_LOGI("Cam::%d BinEn:%d ConfigPort[%d]:0x%x", getOpenId(), mIsBinEn, |
| mConfigPortNum, mConfigPort); |
| |
| mLogInfo.setMemo(LogInfo::CP_OP_START_END, mBurstNum, mEnableCaptureFlow, |
| mInitReqSet, LogInfo::START_SET_CAPTURE); |
| |
| FUNCTION_OUT; |
| |
| return OK; |
| #else |
| return OK; |
| #endif |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::procedureAid_start() { |
| FUNCTION_IN; |
| P1_TRACE_AUTO(SLG_S, "P1:aid_start"); |
| MERROR status = OK; |
| if (mpConCtrl != nullptr && mpConCtrl->getStageCtrl() != nullptr) { |
| MBOOL success = MFALSE; |
| mpConCtrl->getStageCtrl()->wait((MUINT32)STAGE_DONE_START, &success); |
| if (!success) { |
| MY_LOGE("stage - aid start fail"); |
| return BAD_VALUE; |
| } |
| } |
| // |
| MBOOL init_success = MTRUE; |
| status = buildInitItem(); |
| if (OK != status) { |
| init_success = MFALSE; |
| MY_LOGE("CANNOT build init item"); |
| } |
| if (mpConCtrl != nullptr && mpConCtrl->getStageCtrl() != nullptr) { |
| mpConCtrl->getStageCtrl()->done((MUINT32)STAGE_DONE_INIT_ITEM, |
| init_success); |
| } |
| // |
| FUNCTION_OUT; |
| return status; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::buildInitItem() { |
| FUNCTION_IN; |
| P1_TRACE_AUTO(SLG_S, "P1:reserve_init"); |
| if (getReady()) { |
| MY_LOGW("it should be executed before start ready"); |
| return BAD_VALUE; |
| } |
| // |
| if (mpTaskCtrl == nullptr || mpTaskCollector == nullptr) { |
| return BAD_VALUE; |
| } |
| P1QueJob job(mBurstNum); |
| mpTaskCtrl->sessionLock(); |
| P1TaskCollector initCollector(mpTaskCtrl); |
| for (int i = 0; i < mBurstNum; i++) { |
| P1QueAct initAct; |
| initCollector.enrollAct(&initAct); |
| createAction(&initAct, nullptr, REQ_TYPE_INITIAL); |
| initCollector.verifyAct(&initAct); |
| } |
| initCollector.requireJob(&job); |
| mpTaskCtrl->sessionUnLock(); |
| // |
| if (!job.ready()) { |
| MY_LOGE("init-job-not-ready"); |
| mpTaskCtrl->dumpActPool(); |
| return BAD_VALUE; |
| } else { |
| std::lock_guard<std::mutex> _l(mProcessingQueueLock); |
| mProcessingQueue.push_back(job); |
| } |
| // |
| P1QueJob& p_job = mProcessingQueue.at(mProcessingQueue.size() - 1); |
| QBufInfo* pEnBuf = nullptr; |
| if (mpConCtrl == nullptr || (!mpConCtrl->initBufInfo_create(&pEnBuf)) || |
| pEnBuf == nullptr) { |
| MY_LOGE("CANNOT create the initBufInfo"); |
| return BAD_VALUE; |
| } |
| for (size_t i = 0; i < p_job.size(); i++) { |
| MY_LOGD("p_job(%d)(%zu/%zu)", p_job.getIdx(), i, p_job.size()); |
| if (OK != setupAction(&p_job.edit(i), pEnBuf)) { |
| MY_LOGE("setup enque act fail"); |
| return BAD_VALUE; |
| } |
| P1Act act = GET_ACT_PTR(act, p_job.edit(i), BAD_VALUE); |
| act->exeState = EXE_STATE_PROCESSING; |
| } |
| // |
| FUNCTION_OUT; |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::generateAppMeta(P1QueAct* rAct, |
| NS3Av3::MetaSet_T const& result3A, |
| QBufInfo const& deqBuf, |
| IMetadata* appMetadata, |
| MUINT32 const index) { |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| if (act->appFrame == nullptr) { |
| MY_LOGW("pipeline frame is NULL (%d)", act->magicNum); |
| return; |
| } |
| std::shared_ptr<IPipelineFrame> request = act->appFrame; |
| |
| // [3A/Flash/sensor section] |
| (*appMetadata) = result3A.appMeta; |
| |
| MBOOL needOverrideTimestamp = MFALSE; |
| if (tryGetMetadata<MBOOL>(&result3A.halMeta, MTK_EIS_NEED_OVERRIDE_TIMESTAMP, |
| &needOverrideTimestamp) && |
| needOverrideTimestamp) { |
| IMetadata::IEntry entry(MTK_EIS_FEATURE_ISNEED_OVERRIDE_TIMESTAMP); |
| entry.push_back(1, Type2Type<MUINT8>()); // Need Override timestamp |
| entry.push_back(0, Type2Type<MUINT8>()); // timestamp not overrided yet |
| (*appMetadata).update(MTK_EIS_FEATURE_ISNEED_OVERRIDE_TIMESTAMP, entry); |
| } |
| |
| // [request section] |
| // android.request.frameCount |
| { |
| IMetadata::IEntry entry(MTK_REQUEST_FRAME_COUNT); |
| entry.push_back(request->getFrameNo(), Type2Type<MINT32>()); |
| (*appMetadata).update(MTK_REQUEST_FRAME_COUNT, entry); |
| } |
| // android.request.metadataMode |
| { |
| IMetadata::IEntry entry(MTK_REQUEST_METADATA_MODE); |
| entry.push_back(MTK_REQUEST_METADATA_MODE_FULL, Type2Type<MUINT8>()); |
| (*appMetadata).update(MTK_REQUEST_METADATA_MODE, entry); |
| } |
| |
| // [sensor section] |
| // android.sensor.timestamp |
| { |
| MINT64 frame_duration = 0; |
| #if 1 // modify timestamp |
| frame_duration = act->frameExpDuration; |
| #endif |
| // ISP SOF : ISP get the first line from sensor |
| MINT64 Sof = (deqBuf.mvOut[index].mMetaData.mTimeStamp_B != 0) |
| ? deqBuf.mvOut[index].mMetaData.mTimeStamp_B |
| : deqBuf.mvOut[index].mMetaData.mTimeStamp; |
| MINT64 timestamp = (Sof != 0) ? (Sof - frame_duration) : 0; |
| IMetadata::IEntry entry(MTK_SENSOR_TIMESTAMP); |
| entry.push_back(timestamp, Type2Type<MINT64>()); |
| (*appMetadata).update(MTK_SENSOR_TIMESTAMP, entry); |
| } |
| |
| // [sensor section] |
| // android.sensor.rollingshutterskew |
| { |
| MINT64 skew = 0; |
| queryRollingSkew(getOpenId(), &skew, mLogLevelI); |
| IMetadata::IEntry entry(MTK_SENSOR_ROLLING_SHUTTER_SKEW); |
| entry.push_back(skew, Type2Type<MINT64>()); |
| (*appMetadata).update(MTK_SENSOR_ROLLING_SHUTTER_SKEW, entry); |
| } |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::generateAppTagIndex(IMetadata* appMetadata, IMetadata* appTagIndex) { |
| IMetadata::IEntry entryTagIndex(MTK_P1NODE_METADATA_TAG_INDEX); |
| |
| for (size_t i = 0; i < (*appMetadata).count(); ++i) { |
| IMetadata::IEntry entry = (*appMetadata).entryAt(i); |
| entryTagIndex.push_back((MINT32)entry.tag(), Type2Type<MINT32>()); |
| } |
| |
| if (OK != (*appTagIndex).update(entryTagIndex.tag(), entryTagIndex)) { |
| MY_LOGE("fail to update index"); |
| } |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::generateHalMeta(P1QueAct* rAct, |
| NS3Av3::MetaSet_T const& result3A, |
| QBufInfo const& deqBuf, |
| IMetadata const& resultAppend, |
| IMetadata const& inHalMetadata, |
| IMetadata* halMetadata, |
| MUINT32 const index) { |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| if (deqBuf.mvOut.size() == 0) { |
| MY_LOGE("deqBuf is empty"); |
| return; |
| } |
| |
| // 3a tuning |
| *halMetadata = result3A.halMeta; |
| |
| // append |
| *halMetadata += resultAppend; |
| |
| // in hal meta |
| *halMetadata += inHalMetadata; |
| |
| { |
| IMetadata::IEntry entry(MTK_P1NODE_SENSOR_MODE); |
| entry.push_back(mSensorParams.mode, Type2Type<MINT32>()); |
| (*halMetadata).update(MTK_P1NODE_SENSOR_MODE, entry); |
| } |
| |
| { |
| IMetadata::IEntry entry(MTK_P1NODE_SENSOR_VHDR_MODE); |
| entry.push_back(mSensorParams.vhdrMode, Type2Type<MINT32>()); |
| (*halMetadata).update(MTK_P1NODE_SENSOR_VHDR_MODE, entry); |
| } |
| |
| { |
| IMetadata::IEntry entry(MTK_PIPELINE_FRAME_NUMBER); |
| entry.push_back(act->appFrame->getFrameNo(), Type2Type<MINT32>()); |
| (*halMetadata).update(MTK_PIPELINE_FRAME_NUMBER, entry); |
| } |
| |
| // rrzo |
| MUINT32 port_index = act->portBufIndex[P1_OUTPUT_PORT_RRZO]; |
| if (port_index != P1_PORT_BUF_IDX_NONE) { |
| ResultMetadata const* result = &(deqBuf.mvOut[port_index].mMetaData); |
| if (result == nullptr) { |
| MY_LOGE("CANNOT get result at (%d) for (%d)", port_index, index); |
| return; |
| } |
| // crop region |
| MRect crop = result->mCrop_s; |
| MBOOL bIsBinEn = (act->refBinSize == mSensorParams.size) ? MFALSE : MTRUE; |
| { |
| IMetadata::IEntry entry_br(MTK_P1NODE_BIN_CROP_REGION); |
| entry_br.push_back(result->mCrop_s, Type2Type<MRect>()); |
| (*halMetadata).update(MTK_P1NODE_BIN_CROP_REGION, entry_br); |
| IMetadata::IEntry entry_bs(MTK_P1NODE_BIN_SIZE); |
| entry_bs.push_back(act->refBinSize, Type2Type<MSize>()); |
| (*halMetadata).update(MTK_P1NODE_BIN_SIZE, entry_bs); |
| // |
| if (bIsBinEn) { |
| BIN_REVERT(crop.p.x); |
| BIN_REVERT(crop.p.y); |
| BIN_REVERT(crop.s.w); |
| BIN_REVERT(crop.s.h); |
| } |
| IMetadata::IEntry entry(MTK_P1NODE_SCALAR_CROP_REGION); |
| entry.push_back(crop, Type2Type<MRect>()); |
| (*halMetadata).update(MTK_P1NODE_SCALAR_CROP_REGION, entry); |
| } |
| // |
| { |
| IMetadata::IEntry entry(MTK_P1NODE_DMA_CROP_REGION); |
| entry.push_back(result->mCrop_d, Type2Type<MRect>()); |
| (*halMetadata).update(MTK_P1NODE_DMA_CROP_REGION, entry); |
| } |
| // |
| { |
| IMetadata::IEntry entry(MTK_P1NODE_RESIZER_SIZE); |
| entry.push_back(result->mDstSize, Type2Type<MSize>()); |
| (*halMetadata).update(MTK_P1NODE_RESIZER_SIZE, entry); |
| } |
| // |
| MINT32 quality = MTK_P1_RESIZE_QUALITY_LEVEL_UNKNOWN; |
| { |
| if (result->eIQlv == eCamIQ_L) { |
| quality = MTK_P1_RESIZE_QUALITY_LEVEL_L; |
| } else if (result->eIQlv == eCamIQ_H) { |
| quality = MTK_P1_RESIZE_QUALITY_LEVEL_H; |
| } |
| IMetadata::IEntry entry(MTK_P1NODE_RESIZE_QUALITY_LEVEL); |
| entry.push_back(quality, Type2Type<MINT32>()); |
| (*halMetadata).update(MTK_P1NODE_RESIZE_QUALITY_LEVEL, entry); |
| } |
| MY_LOGI("[CropInfo] Bin(%d) Sensor" P1_SIZE_STR "ActRef" P1_SIZE_STR |
| "CROP_REGION" P1_RECT_STR "CropS" P1_RECT_STR "CropD" P1_RECT_STR |
| "DstSize" P1_SIZE_STR "- [BinQty] QUALITY_LEVEL(%d) IQlv(%d)", |
| bIsBinEn, P1_SIZE_VAR(mSensorParams.size), |
| P1_SIZE_VAR(act->refBinSize), P1_RECT_VAR(crop), |
| P1_RECT_VAR(result->mCrop_s), P1_RECT_VAR(result->mCrop_d), |
| P1_SIZE_VAR(result->mDstSize), quality, result->eIQlv); |
| } |
| // |
| { |
| MINT64 timestamp = deqBuf.mvOut[index].mMetaData.mTimeStamp; |
| IMetadata::IEntry entry(MTK_P1NODE_FRAME_START_TIMESTAMP); |
| entry.push_back(timestamp, Type2Type<MINT64>()); |
| (*halMetadata).update(MTK_P1NODE_FRAME_START_TIMESTAMP, entry); |
| } |
| |
| { |
| MINT64 timestamp_boot = deqBuf.mvOut[index].mMetaData.mTimeStamp_B; |
| IMetadata::IEntry entry(MTK_P1NODE_FRAME_START_TIMESTAMP_BOOT); |
| entry.push_back(timestamp_boot, Type2Type<MINT64>()); |
| (*halMetadata).update(MTK_P1NODE_FRAME_START_TIMESTAMP_BOOT, entry); |
| } |
| // |
| if ((mIsDynamicTwinEn) && (mpCamIO != nullptr)) { |
| MBOOL ret = MFALSE; |
| MINT32 status = MTK_P1_TWIN_STATUS_NONE; |
| E_CamHwPathCfg curCfg = eCamHwPathCfg_Num; |
| ret = mpCamIO->sendCommand(ENPipeCmd_GET_HW_PATH_CFG, (MINTPTR)(&curCfg), |
| (MINTPTR)NULL, (MINTPTR)NULL); |
| if (ret) { |
| switch (curCfg) { |
| case eCamHwPathCfg_One_TG: |
| status = MTK_P1_TWIN_STATUS_TG_MODE_1; |
| break; |
| case eCamHwPathCfg_Two_TG: |
| status = MTK_P1_TWIN_STATUS_TG_MODE_2; |
| break; |
| // case eCamHwPathCfg_Num: |
| default: |
| MY_LOGI("CamHwPathCfg_Num(%d) not defined", curCfg); |
| break; |
| } |
| IMetadata::IEntry entry(MTK_P1NODE_TWIN_STATUS); |
| entry.push_back(status, Type2Type<MINT32>()); |
| (*halMetadata).update(MTK_P1NODE_TWIN_STATUS, entry); |
| } else { |
| MY_LOGI("cannot get ENPipeCmd_GET_HW_PATH_CFG (%d)", ret); |
| } |
| MY_LOGI("(%d)=GET_HW_PATH_CFG(%d) TWIN_STATUS[%d] @ (%d)(%d:%d)", ret, |
| curCfg, status, act->magicNum, act->frmNum, act->reqNum); |
| } |
| // |
| MINT32 qtyStatus = MTK_P1_RESIZE_QUALITY_STATUS_NONE; |
| if (act->qualitySwitchState != QUALITY_SWITCH_STATE_NONE) { |
| switch (act->qualitySwitchState) { |
| case QUALITY_SWITCH_STATE_DONE_ACCEPT: |
| qtyStatus = MTK_P1_RESIZE_QUALITY_STATUS_ACCEPT; |
| break; |
| case QUALITY_SWITCH_STATE_DONE_IGNORE: |
| qtyStatus = MTK_P1_RESIZE_QUALITY_STATUS_IGNORE; |
| break; |
| case QUALITY_SWITCH_STATE_DONE_REJECT: |
| qtyStatus = MTK_P1_RESIZE_QUALITY_STATUS_REJECT; |
| break; |
| case QUALITY_SWITCH_STATE_DONE_ILLEGAL: |
| qtyStatus = MTK_P1_RESIZE_QUALITY_STATUS_ILLEGAL; |
| break; |
| default: |
| break; |
| } |
| IMetadata::IEntry entry(MTK_P1NODE_RESIZE_QUALITY_STATUS); |
| entry.push_back(qtyStatus, Type2Type<MINT32>()); |
| (*halMetadata).update(MTK_P1NODE_RESIZE_QUALITY_STATUS, entry); |
| } |
| // |
| MBOOL qtySwitch = getQualitySwitching(); |
| { |
| IMetadata::IEntry entry(MTK_P1NODE_RESIZE_QUALITY_SWITCHING); |
| entry.push_back(qtySwitch, Type2Type<MBOOL>()); |
| (*halMetadata).update(MTK_P1NODE_RESIZE_QUALITY_SWITCHING, entry); |
| } |
| // |
| MY_LOGI("QUALITY_STATUS[%d](%d) - QUALITY_SWITCHING[%d] - " P1NUM_ACT_STR, |
| qtyStatus, act->qualitySwitchState, qtySwitch, P1NUM_ACT_VAR(*act)); |
| // |
| if (CC_UNLIKELY(act->isRawTypeChanged)) { |
| MINT32 rawType = act->fullRawType; |
| IMetadata::IEntry entry(MTK_P1NODE_RAW_TYPE); |
| entry.push_back(rawType, Type2Type<MINT32>()); |
| (*halMetadata).update(MTK_P1NODE_RAW_TYPE, entry); |
| MY_LOGI("MTK_P1NODE_RAW_TYPE(%d) - full raw type change - " P1NUM_ACT_STR, |
| rawType, P1NUM_ACT_VAR(*act)); |
| } |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::setupAction(P1QueAct* rAct, QBufInfo* info) { |
| FUNCTION_IN; |
| P1Act act = GET_ACT_PTR(act, *rAct, BAD_VALUE); |
| #if SUPPORT_ISP |
| MUINT32 out = 0; |
| // |
| std::shared_ptr<IImageStreamInfo> pImgStreamInfo = nullptr; |
| std::shared_ptr<IImageBuffer> pImgBuf = nullptr; |
| |
| // |
| NSCam::NSIoPipe::PortID portID = NSCam::NSIoPipe::PortID(); |
| MSize dstSize = MSize(0, 0); |
| MRect cropRect = MRect(MPoint(0, 0), MSize(0, 0)); |
| MUINT32 rawOutFmt = 0; |
| // |
| STREAM_IMG streamImg = STREAM_IMG_NUM; |
| // |
| if ((act->reqType == REQ_TYPE_UNKNOWN) || (act->reqType == REQ_TYPE_REDO) || |
| (act->reqType == REQ_TYPE_YUV)) { |
| MY_LOGW("mismatch act type " P1INFO_ACT_STR, P1INFO_ACT_VAR(*act)); |
| return BAD_VALUE; |
| } |
| // |
| P1_TRACE_F_BEGIN(SLG_I, "P1:setup|Mnum:%d SofIdx:%d Fnum:%d Rnum:%d", |
| act->magicNum, act->sofIdx, act->frmNum, act->reqNum); |
| // |
| #if (IS_P1_LOGI) |
| std::string strInfo(""); |
| #endif |
| // |
| for (out = 0; out < REQ_OUT_MAX; out++) { |
| if (!(IS_OUT(out, act->reqOutSet))) { |
| continue; |
| } |
| P1_TRACE_F_BEGIN(SLG_I, "REQ_OUT_%d", out); |
| pImgStreamInfo = nullptr; |
| pImgBuf = nullptr; |
| streamImg = STREAM_IMG_NUM; |
| switch (out) { |
| case REQ_OUT_LCSO: |
| case REQ_OUT_LCSO_STUFF: |
| streamImg = STREAM_IMG_OUT_LCS; |
| portID = PORT_LCSO; |
| dstSize = mvStreamImg[streamImg]->getImgSize(); |
| cropRect = MRect(MPoint(0, 0), mvStreamImg[streamImg]->getImgSize()); |
| rawOutFmt = (EPipe_PROCESSED_RAW); |
| if (out == REQ_OUT_LCSO_STUFF) { |
| // not use stuff buffer with height:1 |
| cropRect.s = dstSize; |
| } |
| break; |
| |
| case REQ_OUT_RSSO: |
| case REQ_OUT_RSSO_STUFF: |
| streamImg = STREAM_IMG_OUT_RSS; |
| portID = PORT_RSSO; |
| dstSize = mvStreamImg[streamImg]->getImgSize(); |
| cropRect = MRect(MPoint(0, 0), mvStreamImg[streamImg]->getImgSize()); |
| rawOutFmt = (EPipe_PROCESSED_RAW); |
| if (out == REQ_OUT_RSSO_STUFF) { |
| // not use stuff buffer with height:1 |
| cropRect.s = dstSize; |
| } |
| break; |
| |
| case REQ_OUT_RESIZER: |
| case REQ_OUT_RESIZER_STUFF: |
| streamImg = STREAM_IMG_OUT_RESIZE; |
| portID = PORT_RRZO; |
| dstSize = act->dstSize_resizer; |
| cropRect = act->cropRect_resizer; |
| rawOutFmt = (EPipe_PROCESSED_RAW); |
| if (out == REQ_OUT_RESIZER_STUFF) { |
| // use stuff buffer with height:1 |
| cropRect.s = dstSize; |
| } |
| break; |
| |
| case REQ_OUT_FULL_PROC: |
| case REQ_OUT_FULL_PURE: |
| case REQ_OUT_FULL_OPAQUE: |
| case REQ_OUT_FULL_STUFF: |
| streamImg = STREAM_IMG_OUT_FULL; |
| if (out == REQ_OUT_FULL_OPAQUE || |
| (out == REQ_OUT_FULL_STUFF && |
| act->streamBufImg[STREAM_IMG_OUT_OPAQUE].bExist)) { |
| streamImg = STREAM_IMG_OUT_OPAQUE; |
| } else if (mvStreamImg[STREAM_IMG_OUT_FULL] != nullptr) { |
| streamImg = STREAM_IMG_OUT_FULL; |
| } else if (mvStreamImg[STREAM_IMG_OUT_OPAQUE] != nullptr) { |
| streamImg = STREAM_IMG_OUT_OPAQUE; |
| } |
| portID = PORT_IMGO; |
| dstSize = act->dstSize_full; |
| cropRect = act->cropRect_full; |
| rawOutFmt = act->fullRawType; |
| // |
| if (out == REQ_OUT_FULL_STUFF) { |
| cropRect.s = dstSize; |
| } |
| break; |
| } |
| // |
| if (streamImg < STREAM_IMG_NUM) { |
| pImgStreamInfo = mvStreamImg[streamImg]; |
| } else { |
| MY_LOGW( |
| "cannot find the StreamImg num:%d out:%d " |
| "streamImg:%d", |
| act->magicNum, out, streamImg); |
| return BAD_VALUE; |
| } |
| if (pImgStreamInfo == nullptr) { |
| MY_LOGW( |
| "cannot find the ImgStreamInfo num:%d out:%d " |
| "streamImg:%d", |
| act->magicNum, out, streamImg); |
| return BAD_VALUE; |
| } |
| // |
| MERROR err = OK; |
| if (out == REQ_OUT_FULL_STUFF || out == REQ_OUT_RESIZER_STUFF || |
| out == REQ_OUT_LCSO_STUFF || out == REQ_OUT_RSSO_STUFF) { |
| err = act->stuffImageGet(streamImg, dstSize, &pImgBuf); |
| } else if (act->reqType == REQ_TYPE_INITIAL) { |
| // the initial act with the pool, it do not use the stuff buffer |
| err = act->poolImageGet(streamImg, &pImgBuf); |
| } else { // REQ_TYPE_NORMAL |
| if (OK != act->frameImageGet(streamImg, &pImgBuf)) { |
| // keep en-queue/de-queue processing |
| if (out == REQ_OUT_LCSO || out == REQ_OUT_RSSO || |
| ((mEnableDumpRaw || mCamDumpEn) && |
| (out == REQ_OUT_FULL_PURE || out == REQ_OUT_FULL_PROC || |
| out == REQ_OUT_FULL_OPAQUE))) { |
| MY_LOGI("keep the output size out:%d", out); |
| } else { |
| cropRect.s.h = dstSize.h; |
| } |
| err = act->stuffImageGet(streamImg, dstSize, &pImgBuf); |
| if (out == REQ_OUT_RESIZER) { |
| act->expRec |= EXP_REC(EXP_EVT_NOBUF_RRZO); |
| } else if (out == REQ_OUT_LCSO) { |
| act->expRec |= EXP_REC(EXP_EVT_NOBUF_LCSO); |
| } else if (out == REQ_OUT_RSSO) { |
| act->expRec |= EXP_REC(EXP_EVT_NOBUF_RSSO); |
| } else { |
| act->expRec |= EXP_REC(EXP_EVT_NOBUF_IMGO); |
| } |
| MY_LOGI( |
| "underway-stuff-buffer status(%d) out[%s](%d) " |
| "stream(%#" PRIx64 ") " P1INFO_ACT_STR, |
| err, P1_PORT_TO_STR(portID), out, pImgStreamInfo->getStreamId(), |
| P1INFO_ACT_VAR(*act)); |
| } |
| } |
| // |
| if (CC_UNLIKELY((pImgBuf == nullptr) || (err != OK))) { |
| MY_LOGE("Cannot get ImgBuf status(%d) out[%s](%d)" P1INFO_ACT_STR, err, |
| P1_PORT_TO_STR(portID), out, P1INFO_ACT_VAR(*act)); |
| mLogInfo.inspect(LogInfo::IT_BUFFER_EXCEPTION); |
| return BAD_VALUE; |
| } |
| // |
| if ((out == REQ_OUT_RESIZER || out == REQ_OUT_RESIZER_STUFF) || |
| (out == REQ_OUT_FULL_PURE || out == REQ_OUT_FULL_PROC || |
| out == REQ_OUT_FULL_OPAQUE || out == REQ_OUT_FULL_STUFF)) { |
| std::shared_ptr<IImageBufferHeap> pHeap = pImgBuf->getImageBufferHeap(); |
| if (pHeap != nullptr) { |
| pHeap->setColorArrangement((MINT32)mSensorFormatOrder); |
| } |
| } |
| // |
| #if (IS_P1_LOGI) |
| if (1 <= mLogLevelI) { |
| strInfo += base::StringPrintf( |
| "[%s][%d](x%x)" |
| "(Buf)(%dx%d)(S:%d:%d P:%p V:%p F:0x%x)" |
| "(Crop)(%d,%d-%dx%d)(%dx%d) ", |
| P1_PORT_TO_STR(portID), out, rawOutFmt, pImgBuf->getImgSize().w, |
| pImgBuf->getImgSize().h, |
| static_cast<int>(pImgBuf->getBufStridesInBytes(0)), |
| static_cast<int>(pImgBuf->getBufSizeInBytes(0)), |
| reinterpret_cast<void*>(pImgBuf->getBufPA(0)), |
| reinterpret_cast<void*>(pImgBuf->getBufVA(0)), |
| pImgBuf->getImgFormat(), cropRect.p.x, cropRect.p.y, cropRect.s.w, |
| cropRect.s.h, dstSize.w, dstSize.h); |
| } |
| #endif |
| BufInfo rBufInfo(portID, pImgBuf.get(), dstSize, cropRect, act->magicNum, |
| act->sofIdx, rawOutFmt); |
| (*info).mvOut.push_back(rBufInfo); |
| P1_TRACE_C_END(SLG_I); // "REQ_OUT" |
| } // end of the loop for each out |
| { |
| if (IS_PORT(CONFIG_PORT_EISO, mConfigPort)) { |
| std::shared_ptr<IImageBuffer> pImgBuf = NULL; |
| MY_LOGD("mpConnectLMV->getBuf +++"); |
| if (IS_LMV(mpConnectLMV)) { |
| mpConnectLMV->getBuf(&pImgBuf); |
| } |
| MY_LOGD("mpConnectLMV->getBuf ---"); |
| if (pImgBuf == NULL) { |
| MY_LOGE("(%d) Cannot get LMV buffer", act->magicNum); |
| return BAD_VALUE; |
| } |
| MY_LOGD(" get LMV out[%s](%d) P(%p) V(%p)" P1INFO_ACT_STR, |
| P1_PORT_TO_STR(PORT_EISO), out, (void*)pImgBuf->getBufPA(0), |
| (void*)pImgBuf->getBufVA(0), P1INFO_ACT_VAR(*act)); |
| act->buffer_eiso = pImgBuf; |
| BufInfo rBufInfo(PORT_EISO, pImgBuf.get(), pImgBuf->getImgSize(), |
| MRect(MPoint(0, 0), pImgBuf->getImgSize()), |
| act->magicNum, act->sofIdx); |
| (*info).mvOut.push_back(rBufInfo); |
| } |
| } |
| mTagEnq.set(rAct->getNum()); |
| if (1 <= mLogLevelI) { |
| P1_TRACE_F_BEGIN(SLG_PFL, |
| "P1::ENQ_LOG|Mnum:%d SofIdx:%d Fnum:%d " |
| "Rnum:%d FlushSet:0x%x", |
| act->magicNum, act->sofIdx, act->frmNum, act->reqNum, |
| act->flushSet); |
| P1_LOGI(1, "[P1::ENQ]" P1INFO_ACT_STR " %s", P1INFO_ACT_VAR(*act), |
| strInfo.c_str()); |
| P1_TRACE_C_END(SLG_PFL); // "P1::ENQ_LOG" |
| } |
| // |
| P1_TRACE_C_END(SLG_I); // "P1:setup" |
| #endif |
| FUNCTION_OUT; |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::hardwareOps_enque(P1QueJob* job, ENQ_TYPE type, MINT64 data) { |
| FUNCTION_IN; |
| P1_TRACE_AUTO(SLG_I, "P1:enque"); |
| |
| if (!getActive()) { |
| return BAD_VALUE; |
| } |
| if (mpCamIO == nullptr) { |
| MY_LOGE("NormalPipe is NULL"); |
| return BAD_VALUE; |
| } |
| MY_LOGD("EnQ[%d](%" PRId64 ") @ (%d)", type, data, job->getIdx()); |
| MBOOL toPush = (type == ENQ_TYPE_INITIAL) ? MFALSE : MTRUE; |
| MBOOL toSwitchUNI = MFALSE; |
| MUINT8 toSwtTgNum = 0; |
| MUINT32 toSwitchQuality = QUALITY_SWITCH_STATE_NONE; |
| #if SUPPORT_ISP |
| // |
| QBufInfo enBuf; |
| QBufInfo* pEnBuf = &enBuf; |
| if ((type == ENQ_TYPE_INITIAL) && (!EN_INIT_REQ_RUN)) { |
| if (mpConCtrl == nullptr || (!mpConCtrl->initBufInfo_get(&pEnBuf)) || |
| pEnBuf == nullptr) { |
| MY_LOGE("CANNOT get the initBufInfo"); |
| return BAD_VALUE; |
| } |
| } else { |
| for (size_t i = 0; i < job->size(); i++) { |
| MY_LOGD("job(%d)(%zu/%zu)", job->getIdx(), i, job->size()); |
| P1QueAct& rAct = job->edit(i); |
| P1Act act = GET_ACT_PTR(act, rAct, BAD_VALUE); |
| if (OK != setupAction(&rAct, &enBuf)) { |
| MY_LOGE("setup enque act fail"); |
| return BAD_VALUE; |
| } |
| if (i == 0 && act->reqType == REQ_TYPE_NORMAL) { |
| if (type == ENQ_TYPE_DIRECTLY) { |
| act->frameExpDuration = data * ONE_US_TO_NS; |
| } |
| enBuf.mShutterTimeNs = act->frameExpDuration; |
| } |
| if (act->uniSwitchState == UNI_SWITCH_STATE_REQ) { |
| toSwitchUNI = MTRUE; |
| } |
| if (act->tgSwitchState == TG_SWITCH_STATE_REQ) { |
| toSwtTgNum = act->tgSwitchNum; |
| } |
| if ((act->qualitySwitchState & QUALITY_SWITCH_STATE_REQ_NON) > 0) { |
| toSwitchQuality = act->qualitySwitchState; |
| } |
| act->exeState = EXE_STATE_PROCESSING; |
| } |
| } |
| // |
| if (EN_START_CAP && (!getReady()) && (type == ENQ_TYPE_NORMAL)) { |
| std::unique_lock<std::mutex> lck(mStartCaptureLock); |
| MUINT32 cnt = 0; |
| std::cv_status res; |
| MY_LOGD("StartCaptureState(%d) Cnt(%d)", mStartCaptureState, cnt); |
| while (mStartCaptureState == START_CAP_STATE_WAIT_CB) { |
| P1_TRACE_F_BEGIN(SLG_S, "StartCapture wait [%d]", cnt); |
| res = mStartCaptureCond.wait_for( |
| lck, std::chrono::nanoseconds(P1_CAPTURE_CHECK_INV_NS)); |
| P1_TRACE_C_END(SLG_S); // "StartCapture wait" |
| if (res == std::cv_status::timeout) { |
| MY_LOGI("StartCap(%d) Cnt(%d) Res(%d)", mStartCaptureState, cnt, res); |
| mLogInfo.inspect(LogInfo::IT_WAIT_CATURE); |
| } else { |
| break; |
| } |
| } |
| P1Act act = GET_ACT_PTR(act, job->edit(0), BAD_VALUE); |
| act->capType = mStartCaptureType; |
| act->frameExpDuration = mStartCaptureExp; |
| act->sofIdx = mStartCaptureIdx; |
| for (size_t i = 0; i < pEnBuf->mvOut.size(); i++) { |
| pEnBuf->mvOut[i].FrameBased.mSOFidx = mStartCaptureIdx; |
| } |
| pEnBuf->mShutterTimeNs = mStartCaptureExp; |
| } |
| // |
| if (toSwitchUNI) { |
| UNI_SWITCH_STATE uniState = UNI_SWITCH_STATE_REQ; |
| MUINT32 switchState = 0; |
| MBOOL res = MFALSE; |
| if (mpCamIO->sendCommand(ENPipeCmd_GET_UNI_SWITCH_STATE, |
| (MINTPTR)(&switchState), (MINTPTR)NULL, |
| (MINTPTR)NULL) && |
| switchState == 0) { // DRV: If switch state is NULL, then do switch. |
| res = mpCamIO->sendCommand(ENPipeCmd_UNI_SWITCH, (MINTPTR)NULL, |
| (MINTPTR)NULL, (MINTPTR)NULL); |
| if (res) { |
| uniState = UNI_SWITCH_STATE_ACT_ACCEPT; |
| } else { |
| uniState = UNI_SWITCH_STATE_ACT_IGNORE; |
| } |
| } else { |
| uniState = UNI_SWITCH_STATE_ACT_REJECT; |
| } |
| // |
| for (size_t i = 0; i < job->size(); i++) { |
| P1Act act = GET_ACT_PTR(act, job->edit(i), BAD_VALUE); |
| if (act->uniSwitchState == UNI_SWITCH_STATE_REQ) { |
| act->uniSwitchState = uniState; |
| MY_LOGD("UNI-Switch(%d)(%d,%d) drv(%d,%d):(%d)", act->magicNum, |
| act->frmNum, act->reqNum, switchState, res, uniState); |
| } |
| } |
| } |
| // |
| if (toSwtTgNum) { |
| TG_SWITCH_STATE tgState = TG_SWITCH_STATE_DONE_IGNORE; |
| MBOOL res = MFALSE; |
| MBOOL ret = MFALSE; |
| MBOOL rev = MFALSE; |
| MBOOL isOn = MFALSE; |
| E_CamHwPathCfg curCfg = eCamHwPathCfg_Num; |
| E_CamHwPathCfg tarCfg = eCamHwPathCfg_Num; |
| switch (toSwtTgNum) { |
| case 1: |
| tarCfg = eCamHwPathCfg_One_TG; |
| break; |
| case 2: |
| tarCfg = eCamHwPathCfg_Two_TG; |
| break; |
| default: |
| MY_LOGI("check act TG state num (%d)", toSwtTgNum); |
| break; |
| } |
| if (mpCamIO != nullptr) { |
| res = mpCamIO->sendCommand(ENPipeCmd_GET_DTwin_INFO, (MINTPTR)(&isOn), |
| (MINTPTR)NULL, (MINTPTR)NULL); |
| if (res && isOn) { |
| ret = |
| mpCamIO->sendCommand(ENPipeCmd_GET_HW_PATH_CFG, (MINTPTR)(&curCfg), |
| (MINTPTR)NULL, (MINTPTR)NULL); |
| } |
| if (!res) { |
| MY_LOGI("sendCmd ENPipeCmd_GET_DTwin_INFO (%d)", res); |
| } else if (!isOn) { |
| MY_LOGI("DynamicTwin not ready (%d)", isOn); |
| } else if (!ret) { |
| MY_LOGI("sendCmd ENPipeCmd_GET_HW_PATH_CFG (%d)", ret); |
| } else if (curCfg == eCamHwPathCfg_Num) { |
| MY_LOGI("check current num (%d)", curCfg); |
| } else if (tarCfg == eCamHwPathCfg_Num) { |
| MY_LOGI("check target num (%d)", tarCfg); |
| } else if (curCfg == tarCfg) { |
| MY_LOGI("CamHwPathCfg is ready (%d) == (%d)", curCfg, tarCfg); |
| } else { |
| rev = mpCamIO->sendCommand(ENPipeCmd_SET_HW_PATH_CFG, (MINTPTR)(tarCfg), |
| (MINTPTR)NULL, (MINTPTR)NULL); |
| if (!rev) { |
| MY_LOGI("sendCmd ENPipeCmd_SET_HW_PATH_CFG (%d)", rev); |
| tgState = TG_SWITCH_STATE_DONE_REJECT; |
| } else { |
| tgState = TG_SWITCH_STATE_DONE_ACCEPT; |
| } |
| } |
| } |
| // |
| for (size_t i = 0; i < job->size(); i++) { |
| P1Act act = GET_ACT_PTR(act, job->edit(i), BAD_VALUE); |
| if (act->tgSwitchState == TG_SWITCH_STATE_REQ) { |
| act->tgSwitchState = tgState; |
| act->tgSwitchNum = 0; |
| MY_LOGI("TG(%d)(%d,%d) Drv(%d) Swt(%d)(%d,%d)(%d,%d,%d):%d", |
| act->magicNum, act->frmNum, act->reqNum, isOn, toSwtTgNum, |
| curCfg, tarCfg, res, ret, rev, tgState); |
| } |
| } |
| } |
| // |
| if (toSwitchQuality != QUALITY_SWITCH_STATE_NONE) { |
| QUALITY_SWITCH_STATE switchQuality = QUALITY_SWITCH_STATE_DONE_REJECT; |
| MBOOL ret = MFALSE; |
| if (mpCamIO != nullptr && mpRegisterNotify != nullptr) { |
| E_CamIQLevel CamLvA = eCamIQ_L; |
| E_CamIQLevel CamLvB = eCamIQ_L; |
| if ((toSwitchQuality & QUALITY_SWITCH_STATE_REQ_H_A) > 0) { |
| CamLvA = eCamIQ_H; |
| } |
| if ((toSwitchQuality & QUALITY_SWITCH_STATE_REQ_H_B) > 0) { |
| CamLvB = eCamIQ_H; |
| } |
| ret = |
| mpCamIO->sendCommand(ENPipeCmd_SET_QUALITY, |
| (MINTPTR)(mpRegisterNotify->getNotifyQuality()), |
| (MINTPTR)CamLvA, (MINTPTR)CamLvB); |
| if (!ret) { |
| MY_LOGI("sendCommand ENPipeCmd_SET_QUALITY fail(%d)", ret); |
| switchQuality = QUALITY_SWITCH_STATE_DONE_REJECT; |
| setQualitySwitching(MFALSE); |
| } else { |
| switchQuality = QUALITY_SWITCH_STATE_DONE_ACCEPT; |
| } |
| } |
| for (size_t i = 0; i < job->size(); i++) { |
| P1Act act = GET_ACT_PTR(act, job->edit(i), BAD_VALUE); |
| if ((act->qualitySwitchState & QUALITY_SWITCH_STATE_REQ_NON) > 0) { |
| MY_LOGI("ResizeQ (%d)(%d,%d) Ret(%d) QualitySwt(%d => %d)", |
| act->magicNum, act->frmNum, act->reqNum, ret, |
| act->qualitySwitchState, switchQuality); |
| act->qualitySwitchState = switchQuality; |
| } |
| } |
| } |
| // |
| if (toPush) { |
| std::lock_guard<std::mutex> _l(mProcessingQueueLock); |
| mProcessingQueue.push_back(*job); |
| MY_LOGD("Push(%d) to ProQ(%zu)", job->getIdx(), mProcessingQueue.size()); |
| } |
| // |
| MBOOL isErr = MFALSE; |
| P1Act act = GET_ACT_PTR(act, job->edit(0), BAD_VALUE); |
| MINT32 numF = act->frmNum; |
| MINT32 numR = act->reqNum; |
| // check CtrlSync before EnQ |
| if ((IS_BURST_OFF) && // exclude burst mode |
| (type != ENQ_TYPE_INITIAL) && (job->size() >= 1)) { |
| attemptCtrlSync(&(job->edit(0))); |
| } |
| // |
| if ((mspSyncHelper != nullptr) && (type != ENQ_TYPE_INITIAL)) { |
| IMetadata ctrlMeta; |
| act->frameMetadataGet(STREAM_META_IN_HAL, &ctrlMeta); |
| mspSyncHelper->syncEnqHW(getOpenId(), &ctrlMeta); |
| } |
| // |
| if (type == ENQ_TYPE_DIRECTLY) { |
| #if (MTKCAM_HAVE_SANDBOX_SUPPORT == 0) |
| P1_TRACE_F_BEGIN(SLG_E, |
| "P1:DRV-resume|" |
| "Mnum:%d SofIdx:%d Fnum:%d Rnum:%d", |
| act->magicNum, act->sofIdx, numF, numR); |
| MY_LOGI("mpCamIO->resume +++"); |
| if (!mpCamIO->resume((QBufInfo const*)(pEnBuf))) { |
| MY_LOGE("[SUS-RES] DRV resume fail"); |
| if (mpHwStateCtrl != nullptr) { |
| mpHwStateCtrl->dump(); |
| } |
| isErr = MTRUE; |
| } |
| MY_LOGI("mpCamIO->resume ---"); |
| P1_TRACE_C_END(SLG_E); // "P1:DRV-resume" |
| #endif |
| } else { // ENQ_TYPE_NORMAL / ENQ_TYPE_INITIAL |
| mLogInfo.setMemo(LogInfo::CP_ENQ_BGN, act->magicNum, numF, numR, |
| act->sofIdx); |
| P1_TRACE_F_BEGIN(SLG_I, |
| "P1:DRV-enque|" |
| "Mnum:%d SofIdx:%d Fnum:%d Rnum:%d", |
| act->magicNum, act->sofIdx, numF, numR); |
| { |
| IHalSensorList* pHalSensorList = GET_HalSensorList(); |
| IHalSensor* pHalSensor = |
| pHalSensorList->createSensor(LOG_TAG, getOpenId()); |
| MUINT32 sensorDevId = pHalSensorList->querySensorDevIdx(getOpenId()); |
| MY_LOGD("openId %d, sensorDevId %d, mMeta_PatMode %d", getOpenId(), |
| sensorDevId, mMeta_PatMode); |
| MINT ret = pHalSensor->sendCommand( |
| sensorDevId, SENSOR_CMD_SET_TEST_PATTERN_OUTPUT, |
| (MUINTPTR)&mMeta_PatMode, sizeof(MUINT32), 0, sizeof(MUINT32), 0, |
| sizeof(MUINT32)); |
| if (ret != 0) { |
| MY_LOGE("sendCommand set pattern output fail(%d)", ret); |
| } |
| } |
| MY_LOGI("mpCamIO->enque +++"); |
| if (!mpCamIO->enque(*pEnBuf)) { |
| MY_LOGE("DRV-enque fail"); |
| isErr = MTRUE; |
| } |
| MY_LOGI("mpCamIO->enque ---"); |
| P1_TRACE_C_END(SLG_I); // "P1:DRV-enque" |
| mLogInfo.setMemo(LogInfo::CP_ENQ_END, act->magicNum, numF, numR, |
| act->sofIdx); |
| } |
| // |
| if (isErr) { |
| if (toPush) { |
| std::lock_guard<std::mutex> _l(mProcessingQueueLock); |
| Que_T::iterator it = mProcessingQueue.begin(); |
| for (; it != mProcessingQueue.end(); it++) { |
| if ((*it).getIdx() == job->getIdx()) { |
| break; |
| } |
| } |
| if (it != mProcessingQueue.end()) { |
| mProcessingQueue.erase(it); |
| } |
| MY_LOGD("Erase(%d) from ProQ(%zu)", job->getIdx(), |
| mProcessingQueue.size()); |
| } |
| return BAD_VALUE; |
| } |
| // |
| if (type == ENQ_TYPE_INITIAL) { |
| mpConCtrl->initBufInfo_clean(); |
| } |
| #endif |
| FUNCTION_OUT; |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::hardwareOps_deque(QBufInfo* deqBuf) { |
| #if SUPPORT_ISP |
| |
| FUNCTION_IN; |
| P1_TRACE_AUTO(SLG_I, "P1:deque"); |
| |
| if (!getActive()) { |
| return BAD_VALUE; |
| } |
| |
| std::lock_guard<std::mutex> _l(mHardwareLock); |
| if (!getActive()) { |
| return BAD_VALUE; |
| } |
| |
| { |
| // deque buffer, and handle frame and metadata |
| MY_LOGD("%" PRId64 ", %f", mDequeThreadProfile.getAvgDuration(), |
| mDequeThreadProfile.getFps()); |
| QPortID PortID; |
| if (IS_PORT(CONFIG_PORT_IMGO, |
| mConfigPort)) { // (mvOutImage_full.size() > 0) { |
| PortID.mvPortId.push_back(PORT_IMGO); |
| } |
| if (IS_PORT(CONFIG_PORT_RRZO, |
| mConfigPort)) { // (mOutImage_resizer != NULL) { |
| PortID.mvPortId.push_back(PORT_RRZO); |
| } |
| if (IS_PORT(CONFIG_PORT_EISO, mConfigPort)) { |
| PortID.mvPortId.push_back(PORT_EISO); |
| } |
| if (IS_PORT(CONFIG_PORT_LCSO, mConfigPort)) { |
| PortID.mvPortId.push_back(PORT_LCSO); |
| } |
| if (IS_PORT(CONFIG_PORT_RSSO, mConfigPort)) { |
| PortID.mvPortId.push_back(PORT_RSSO); |
| } |
| |
| // for mBurstNum: 4 and port: I+R+E+L, the buffer is as |
| // [I1][I2][I3][I4][R1][R2][R3][R4][E1][E2][E3][E4][L1][L2][L3][L4] |
| mDequeThreadProfile.pulse_down(); |
| // |
| P1_TRACE_F_BEGIN(SLG_I, "P1:DRV-deque@[0x%X]", mConfigPort); |
| mLogInfo.setMemo(LogInfo::CP_DEQ_BGN); |
| MY_LOGI("mpCamIO->deque +++"); |
| if (!mpCamIO->deque(PortID, deqBuf)) { |
| if (getActive()) { |
| MY_LOGE("DRV-deque fail"); |
| } else { |
| MY_LOGI("DRV-deque fail - after stop"); |
| P1_TRACE_C_END(SLG_I); // "P1:DRV-deque" |
| return OK; |
| } |
| P1_TRACE_C_END(SLG_I); // "P1:DRV-deque" |
| return BAD_VALUE; |
| } |
| MY_LOGI("mpCamIO->deque ---"); |
| mLogInfo.setMemo(LogInfo::CP_DEQ_END, |
| (deqBuf->mvOut.size() > 0) |
| ? (deqBuf->mvOut[0].mMetaData.mMagicNum_hal) |
| : 0); |
| P1_TRACE_C_END(SLG_I); // "P1:DRV-deque" |
| // |
| mDequeThreadProfile.pulse_up(); |
| } |
| for (size_t i = 0; i < deqBuf->mvOut.size(); i++) { |
| MY_LOGI( |
| "P1 width*height:%d*%d, mvPortId %d, mSize %d, getBufSizeInBytes(0) " |
| "%d, mMetaData.mDstSize.w %d, mMetaData.mDstSize.h %d", |
| deqBuf->mvOut[i].mBuffer->getImgSize().w, |
| deqBuf->mvOut[i].mBuffer->getImgSize().h, |
| deqBuf->mvOut[i].mPortID.index, deqBuf->mvOut[i].mSize, |
| deqBuf->mvOut[i].mBuffer->getBufSizeInBytes(0), |
| deqBuf->mvOut[i].mMetaData.mDstSize.w, |
| deqBuf->mvOut[i].mMetaData.mDstSize.h); |
| } |
| // |
| if (mDebugScanLineMask != 0 && mpDebugScanLine != nullptr) { |
| P1_TRACE_AUTO(SLG_E, "DrawScanLine"); |
| for (size_t i = 0; i < deqBuf->mvOut.size(); i++) { |
| if ((deqBuf->mvOut[i].mPortID.index == PORT_RRZO.index && |
| mDebugScanLineMask & DRAWLINE_PORT_RRZO) || |
| (deqBuf->mvOut[i].mPortID.index == PORT_IMGO.index && |
| mDebugScanLineMask & DRAWLINE_PORT_IMGO)) { |
| mpDebugScanLine->drawScanLine( |
| deqBuf->mvOut[i].mBuffer->getImgSize().w, |
| deqBuf->mvOut[i].mBuffer->getImgSize().h, |
| reinterpret_cast<void*>(deqBuf->mvOut[i].mBuffer->getBufVA(0)), |
| deqBuf->mvOut[i].mBuffer->getBufSizeInBytes(0), |
| deqBuf->mvOut[i].mBuffer->getBufStridesInBytes(0)); |
| } |
| } |
| } |
| #if 1 |
| if (mEnableDumpRaw && deqBuf->mvOut.size() > 0) { |
| MUINT32 magicNum = deqBuf->mvOut.at(0).mMetaData.mMagicNum_hal; |
| |
| /* Record previous "debug.p1.pureraw_dump" prop value. |
| * When current prop value is not equal to previous prop value, it will |
| * start dump raw. When current prop value is > 0 value, it will dump |
| * continuous raw. For example, assume current prop value is 10 ,it will |
| * start continuous 10 raw dump. |
| */ |
| static MINT32 prevDumpProp = 0; |
| static MUINT32 continueDumpCount = 0; |
| |
| /* If current "debug.p1.pureraw_dump" prop value < 0, this variable will |
| * save it. This variable is used to continuous magic number dump raws. For |
| * example, assume current prop value is -20. When pipeline starts, it will |
| * dump frames with magic num < 20. |
| */ |
| static MUINT32 indexRawDump = 0; |
| |
| MINT32 currentDumpProp = |
| property_get_int32("vendor.debug.p1.pureraw_dump", 0); |
| |
| if (prevDumpProp != currentDumpProp) { |
| if (currentDumpProp == 0) { |
| prevDumpProp = 0; |
| indexRawDump = 0; |
| continueDumpCount = 0; |
| } else if (currentDumpProp < 0) { |
| indexRawDump = (MUINT32)(-currentDumpProp); |
| } else if (currentDumpProp > 0) { |
| continueDumpCount = (MUINT32)currentDumpProp; |
| } |
| prevDumpProp = currentDumpProp; |
| } |
| |
| if ((magicNum <= indexRawDump) || continueDumpCount > 0) { |
| if (continueDumpCount > 0) { |
| continueDumpCount--; |
| } |
| |
| for (size_t i = 0; i < deqBuf->mvOut.size(); i++) { |
| char filename[256] = {0}; |
| snprintf(filename, sizeof(filename), |
| "%s/p1_%u_%d_%04dx%04d_%04d_%d.raw", P1NODE_DUMP_PATH, |
| magicNum, |
| ((deqBuf->mvOut.at(i).mPortID.index == PORT_RRZO.index) ? (0) |
| : (1)), |
| static_cast<int>(deqBuf->mvOut.at(i).mBuffer->getImgSize().w), |
| static_cast<int>(deqBuf->mvOut.at(i).mBuffer->getImgSize().h), |
| static_cast<int>( |
| deqBuf->mvOut.at(i).mBuffer->getBufStridesInBytes(0)), |
| static_cast<int>(mSensorFormatOrder)); |
| P1_TRACE_AUTO(SLG_E, filename); |
| deqBuf->mvOut.at(i).mBuffer->saveToFile(filename); |
| MY_LOGI("save to file : %s", filename); |
| } |
| } |
| } |
| #endif |
| |
| FUNCTION_OUT; |
| |
| return OK; |
| #else |
| return OK; |
| #endif |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::hardwareOps_stop() { |
| #if SUPPORT_ISP |
| P1_TRACE_AUTO(SLG_B, "P1:hardwareOps_stop"); |
| |
| // (1) handle active flag |
| if (!getActive()) { |
| MY_LOGD("active=%d - return", getActive()); |
| return OK; |
| } |
| |
| FUNCTION_IN; |
| MY_LOGI("Cam::%d Req=%d Set=%d Enq=%d Deq=%d Out=%d", getOpenId(), |
| mTagReq.get(), mTagSet.get(), mTagEnq.get(), mTagDeq.get(), |
| mTagOut.get()); |
| |
| MINT32 frmNum = P1_FRM_NUM_NULL; |
| MINT32 reqNum = P1_REQ_NUM_NULL; |
| MINT32 cnt = lastFrameRequestInfoNotice(&frmNum, &reqNum); |
| mLogInfo.setMemo(LogInfo::CP_OP_STOP_BGN, frmNum, reqNum, cnt); |
| |
| setActive(MFALSE); |
| setReady(MFALSE); |
| setStartState(NSP1Node::START_STATE_NULL); |
| // |
| { |
| std::lock_guard<std::mutex> _ll(mFrameSetLock); |
| mFrameSetAlready = MFALSE; |
| } |
| // |
| if (getInit()) { |
| MY_LOGI("mHardwareLock waiting +++"); |
| std::lock_guard<std::mutex> _l(mHardwareLock); |
| MY_LOGI("mHardwareLock waiting ---"); |
| } |
| |
| if (mpHwStateCtrl != nullptr) { |
| mpHwStateCtrl->reset(); |
| } |
| |
| // (2.2) stop 3A stt |
| #if SUPPORT_3A |
| if (mp3A) { |
| std::lock_guard<std::mutex> _sl(mStopSttLock); |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_STOP_3A_STOPSTT_BGN, |
| LogInfo::CP_OP_STOP_3A_STOPSTT_END); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-stopStt"); |
| MY_LOGI("mp3A->stopStt +++"); |
| mp3A->stopStt(); |
| MY_LOGI("mp3A->stopStt ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-stopStt" |
| } |
| #endif |
| |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| // stop v4l2sttpipe after 3A |
| MY_LOGI("stop V4L2SttPipeMgr +++"); |
| if (CC_LIKELY(mpV4L2SttPipe.get() != nullptr)) { |
| mpV4L2SttPipe->stop(); |
| mpV4L2SttPipe = nullptr; |
| } |
| MY_LOGI("stop V4L2SttPipeMgr ---"); |
| |
| // stop Event listener |
| MY_LOGI("stop V4L2HwEventWorker +++"); |
| auto _stopHwEventMgr = [this](size_t idx) -> void { |
| if (mpV4L2HwEventMgr[idx].get() == nullptr) { |
| return; |
| } |
| |
| mpV4L2HwEventMgr[idx]->requestExit(); // request to exit first, |
| mpV4L2HwEventMgr[idx]->signal(); // send a fake signal ASAP |
| mpV4L2HwEventMgr[idx]->stop(); // stop loop |
| mpV4L2HwEventMgr[idx] = nullptr; // release resource |
| }; |
| _stopHwEventMgr(0); |
| _stopHwEventMgr(1); |
| _stopHwEventMgr(2); |
| MY_LOGI("stop V4L2HwEventWorker ---"); |
| #endif |
| |
| // (2.3) stop isp |
| if (CC_UNLIKELY(mpCamIO == nullptr)) { |
| MY_LOGE("hardware CamIO not exist"); |
| return BAD_VALUE; |
| } |
| { |
| // std::lock_guard<std::mutex> _l(mHardwareLock); |
| if (mLongExp.get()) { |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_STOP_DRV_STOP_BGN, |
| LogInfo::CP_OP_STOP_DRV_STOP_END, |
| MTRUE /* call abort */); |
| #if (MTKCAM_HAVE_SANDBOX_SUPPORT == 0) |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-abort"); |
| MY_LOGI("mpCamIO->abort +++"); |
| if (!mpCamIO->abort()) { |
| MY_LOGE("hardware abort fail"); |
| // return BAD_VALUE; |
| } |
| MY_LOGI("mpCamIO->abort ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-abort" |
| #endif |
| } else { |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_STOP_DRV_STOP_BGN, |
| LogInfo::CP_OP_STOP_DRV_STOP_END, |
| MFALSE /* not abort */); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-stop"); |
| MY_LOGI("mpCamIO->stop +++"); |
| if (!mpCamIO->stop(/*MTRUE*/)) { |
| MY_LOGE("hardware stop fail"); |
| } |
| MY_LOGI("mpCamIO->stop ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-stop" |
| } |
| } |
| |
| mLogInfo.setMemo(LogInfo::CP_OP_STOP_HW_LOCK_BGN); |
| MY_LOGI("HwLockStopWait +++"); |
| std::lock_guard<std::mutex> _l(mHardwareLock); |
| MY_LOGI("HwLockStopWait ---"); |
| mLogInfo.setMemo(LogInfo::CP_OP_STOP_HW_LOCK_END); |
| |
| // (3.0) stop 3A |
| #if SUPPORT_3A |
| if (mp3A) { |
| P1_TRACE_C_END(SLG_S); // "P1:LMV-enableOIS" |
| #if SUPPORT_FSC |
| if (mpFSC != nullptr) { |
| mpFSC->Uninit(mp3A); // detach 3A CB before 3A->stop() |
| } |
| #endif |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-sendCtrl-detachCb"); |
| // |
| mp3A->detachCb(IHal3ACb::eID_NOTIFY_3APROC_FINISH, this); |
| mp3A->detachCb(IHal3ACb::eID_NOTIFY_CURR_RESULT, this); |
| mp3A->detachCb(IHal3ACb::eID_NOTIFY_VSYNC_DONE, this); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-sendCtrl-detachCb" |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_STOP_3A_STOP_BGN, |
| LogInfo::CP_OP_STOP_3A_STOP_END); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-stop"); |
| MY_LOGI("mp3A->stop +++"); |
| mp3A->stop(); |
| MY_LOGI("mp3A->stop ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-stop" |
| } |
| #endif |
| |
| // (3.1) destroy 3A |
| #if SUPPORT_3A |
| if (mp3A) { |
| if (getPowerNotify()) { |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OP_STOP_3A_PWROFF_BGN, |
| LogInfo::CP_OP_STOP_3A_PWROFF_END); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-notifyPwrOff"); |
| MY_LOGI("mp3A->notifyP1PwrOff +++"); |
| mp3A->notifyP1PwrOff(); // CCU DRV power off before ISP uninit. |
| MY_LOGI("mp3A->notifyP1PwrOff ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-notifyPwrOff" |
| } else { |
| MY_LOGI("3A->notifyP1PwrOff() no need"); |
| } |
| setPowerNotify(MFALSE); |
| // |
| mp3A = nullptr; |
| } |
| #endif |
| |
| // (3.1.1) stop v4l2 pipe (IPC only) |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| if (mpV4L2LensMgr.get()) { |
| MY_LOGI("stop V4L2LensMgr +++"); |
| mpV4L2LensMgr->stop(); |
| mpV4L2LensMgr = nullptr; |
| MY_LOGI("stop V4L2LensMgr ---"); |
| } |
| if (mpV4L2SensorMgr.get()) { |
| MY_LOGI("stop V4L2SensorWorker +++"); |
| mpV4L2SensorMgr->stop(); |
| mpV4L2SensorMgr = nullptr; // clear resource |
| MY_LOGI("stop V4L2SensorWorker ---"); |
| } |
| if (mpV4L2P13ACallback.get()) { |
| MY_LOGI("stop V4L2P13ACallback +++"); |
| mpV4L2P13ACallback->stop(); |
| mpV4L2P13ACallback = nullptr; |
| MY_LOGI("stop V4L2P13ACallback ---"); |
| } |
| if (mpV4L2TuningPipe.get()) { |
| MY_LOGI("stop V4L2TuningPipeMgr +++"); |
| mpV4L2TuningPipe->stop(); |
| mpV4L2TuningPipe = nullptr; |
| MY_LOGI("stop V4L2TuningPipeMgr ---"); |
| } |
| #endif |
| if (IS_LMV(mpConnectLMV)) { |
| mpConnectLMV->uninit(); |
| } |
| |
| // (3.2) destroy isp |
| { |
| // |
| #if SUPPORT_LCS |
| if (mpLCS) { |
| mpLCS->Uninit(); |
| mpLCS->DestroyInstance( |
| LOG_TAG); // instance always exist until process kill |
| mpLCS = nullptr; |
| } |
| #endif |
| #if SUPPORT_RSS |
| if (mpRSS != nullptr) { |
| mpRSS->Uninit(); |
| mpRSS = nullptr; |
| } |
| #endif |
| #if SUPPORT_FSC |
| mpFSC = nullptr; |
| #endif |
| // |
| mLogInfo.setMemo(LogInfo::CP_OP_STOP_DRV_UNINIT_BGN); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-uninit"); |
| MY_LOGI("mpCamIO->uninit +++"); |
| if (!mpCamIO->uninit()) { |
| MY_LOGE("hardware uninit fail"); |
| // return BAD_VALUE; |
| } |
| MY_LOGI("mpCamIO->uninit ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-uninit" |
| mLogInfo.setMemo(LogInfo::CP_OP_STOP_DRV_UNINIT_END); |
| // |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-destroyInstance"); |
| MY_LOGI("mpCamIO->destroyInstance +++"); |
| mpCamIO = nullptr; |
| MY_LOGI("mpCamIO->destroyInstance ---"); |
| |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-destroyInstance" |
| } |
| // |
| syncHelperStop(); |
| // |
| if (mspResConCtrl != nullptr) { |
| P1NODE_RES_CON_RELEASE(mspResConCtrl, mResConClient, mIsResConGot); |
| } |
| // |
| #if USING_CTRL_3A_LIST_PREVIOUS |
| mPreviousCtrlList.clear(); |
| #endif |
| // |
| mLogInfo.setMemo(LogInfo::CP_OP_STOP_END, frmNum, reqNum, cnt); |
| // |
| FUNCTION_OUT; |
| |
| return OK; |
| |
| #else |
| return OK; |
| #endif |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::hardwareOps_streaming() { |
| P1_TRACE_AUTO(SLG_B, "P1:hardwareOps_streaming"); |
| if (CC_UNLIKELY(mpHwStateCtrl == nullptr)) { |
| return BAD_VALUE; |
| } |
| if (!mpHwStateCtrl->checkReceiveRestreaming()) { |
| return BAD_VALUE; |
| } |
| // |
| if (mpHwStateCtrl->isLegacyStandby()) { |
| MINT32 nShutterTimeUs = 0; |
| mpHwStateCtrl->checkShutterTime(&nShutterTimeUs); |
| #if (MTKCAM_HAVE_SANDBOX_SUPPORT == 0) |
| P1_TRACE_F_BEGIN(SLG_E, "P1:DRV-Resume(%d)", nShutterTimeUs); |
| ret = mpCamIO->resume(nShutterTimeUs); |
| P1_TRACE_C_END(SLG_E); // "P1:DRV-Resume" |
| if (!ret) { |
| MY_LOGE("[SUS-RES] FAIL"); |
| mpHwStateCtrl->dump(); |
| mpHwStateCtrl->clean(); |
| return BAD_VALUE; |
| } |
| #endif |
| // |
| P1_TRACE_S_BEGIN(SLG_E, "P1:3A-Resume"); |
| mp3A->resume(); |
| P1_TRACE_C_END(SLG_E); // "P1:3A-Resume" |
| // |
| MY_LOGI("[SUS-RES] Recover-Loop-N"); |
| // |
| mpHwStateCtrl->checkThreadWeakup(); |
| } else { |
| if (CC_UNLIKELY(mpTaskCtrl == nullptr || mpTaskCollector == nullptr)) { |
| return BAD_VALUE; |
| } |
| P1QueJob job(mBurstNum); |
| mpTaskCollector->requireJob(&job); |
| if (!job.ready()) { |
| MY_LOGE("job-require-fail"); |
| mpTaskCtrl->dumpActPool(); |
| return BAD_VALUE; |
| } |
| P1Act pAct = GET_ACT_PTR(pAct, job.edit(0), BAD_VALUE); |
| if (pAct->ctrlSensorStatus != SENSOR_STATUS_CTRL_STREAMING) { |
| MY_LOGI("status-mismatch(%d)@(%d)", pAct->ctrlSensorStatus, |
| pAct->getNum()); |
| } |
| MINT32 nShutterTimeUs = 0; |
| mpHwStateCtrl->checkShutterTime(&nShutterTimeUs); |
| mpHwStateCtrl->checkRestreamingNum(pAct->getNum()); |
| { |
| P1_TRACE_F_BEGIN(SLG_E, "P1:3A-resume(%d)", pAct->getNum()); |
| mp3A->resume(pAct->getNum()); |
| P1_TRACE_C_END(SLG_E); // "P1:3A-resume" |
| } |
| MERROR status = |
| hardwareOps_enque(&job, ENQ_TYPE_DIRECTLY, (MINT64)nShutterTimeUs); |
| if (OK != status) { |
| MY_LOGE("streaming en-queue fail (%d)@(%d)", status, job.getIdx()); |
| return BAD_VALUE; |
| } |
| // |
| mpHwStateCtrl->checkThreadWeakup(); |
| mpHwStateCtrl->checkFirstSync(); |
| } |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::prepareCropInfo(P1QueAct* rAct, |
| IMetadata* pAppMetadata, |
| IMetadata* pHalMetadata, |
| PREPARE_CROP_PHASE phase, |
| MBOOL* pCtrlFlush) { |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| MSize refSensorSize = getCurrentBinSize(); // mSensorParams.size; |
| MBOOL bIsBinEn = (refSensorSize == mSensorParams.size) ? MFALSE : MTRUE; |
| MBOOL isFullBin = MFALSE; |
| if (bIsBinEn && act->reqType == REQ_TYPE_NORMAL && |
| (/*IS_OUT(REQ_OUT_FULL_PROC, act->reqOutSet) ||*/ |
| act->fullRawType == EPipe_PROCESSED_RAW)) { |
| isFullBin = MTRUE; |
| } |
| MY_LOGI( |
| "[CropInfo][%d] +++ IsBinEn:%d IsFullBin:%d " |
| "sensor(%dx%d) ref(%dx%d)", |
| phase, mIsBinEn, isFullBin, mSensorParams.size.w, mSensorParams.size.h, |
| refSensorSize.w, refSensorSize.h); |
| act->refBinSize = refSensorSize; |
| if (mvStreamImg[STREAM_IMG_OUT_FULL] != nullptr) { |
| act->dstSize_full = mvStreamImg[STREAM_IMG_OUT_FULL]->getImgSize(); |
| act->cropRect_full = |
| MRect(MPoint(0, 0), (isFullBin) ? refSensorSize : mSensorParams.size); |
| } else if (mvStreamImg[STREAM_IMG_OUT_OPAQUE] != nullptr) { |
| act->dstSize_full = mSensorParams.size; |
| act->cropRect_full = |
| MRect(MPoint(0, 0), (isFullBin) ? refSensorSize : mSensorParams.size); |
| } else { |
| act->dstSize_full = MSize(0, 0); |
| act->cropRect_full = MRect(MPoint(0, 0), MSize(0, 0)); |
| } |
| if (mvStreamImg[STREAM_IMG_OUT_RESIZE] != nullptr) { |
| act->dstSize_resizer = mvStreamImg[STREAM_IMG_OUT_RESIZE]->getImgSize(); |
| act->cropRect_resizer = MRect(MPoint(0, 0), refSensorSize); |
| } else { |
| act->dstSize_resizer = MSize(0, 0); |
| act->cropRect_resizer = MRect(MPoint(0, 0), MSize(0, 0)); |
| } |
| MY_LOGI("[CropInfo][%d] --- [F] Src" P1_RECT_STR "Dst" P1_SIZE_STR |
| "[R] Src" P1_RECT_STR "Dst" P1_SIZE_STR, |
| phase, P1_RECT_VAR(act->cropRect_full), |
| P1_SIZE_VAR(act->dstSize_full), P1_RECT_VAR(act->cropRect_resizer), |
| P1_SIZE_VAR(act->dstSize_resizer)); |
| } |
| |
| #if USING_CTRL_3A_LIST |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::generateCtrlList(List<NS3Av3::MetaSet_T>* pList, P1QueJob* rJob) { |
| if (CC_UNLIKELY(pList == nullptr)) { |
| MY_LOGE("List is nullptr"); |
| return; |
| } |
| #define P1_3A_LIST_INDEX (2) |
| size_t total = (P1_3A_LIST_INDEX * mBurstNum); |
| #if USING_CTRL_3A_LIST_PREVIOUS // force to save and set previous metadata |
| // #warning "using previously padding 3A Control List" |
| // add dummy before first request |
| while (mPreviousCtrlList.size() < total) { |
| NS3Av3::MetaSet_T set; |
| set.MagicNum = 0; |
| set.Dummy = 1; |
| mPreviousCtrlList.push_back(set); |
| } |
| // add this request |
| for (size_t j = 0; j < (*rJob).size(); j++) { |
| if ((*rJob).edit(j).ptr() != nullptr) { |
| mPreviousCtrlList.push_back((*rJob).edit(j).ptr()->metaSet); |
| } |
| } |
| // keep list length in (P1_3A_LIST_INDEX + 1) |
| while ((mPreviousCtrlList.size() > (total + mBurstNum))) { |
| mPreviousCtrlList.erase(mPreviousCtrlList.begin()); |
| } |
| // copy the mPreviousCtrlList to set-CtrlList |
| List<NS3Av3::MetaSet_T>::iterator p_it = mPreviousCtrlList.begin(); |
| for (; p_it != mPreviousCtrlList.end(); p_it++) { |
| pList->push_back(*p_it); |
| } |
| #else |
| for (size_t i = 0; i < total; i++) { |
| NS3Av3::MetaSet_T set; |
| pList->push_back(set); |
| } |
| for (size_t j = 0; j < (*rJob).size(); j++) { |
| if ((*rJob).edit(j).ptr() != nullptr) { |
| pList->push_back((*rJob).edit(j).ptr()->metaSet); |
| } |
| } |
| #endif |
| // |
| if (mMetaLogOp > 0 && pList->size() > 0 && |
| pList->size() == ((*rJob).size() * (P1_3A_LIST_INDEX + 1))) { |
| MY_LOGI("LogMeta List[%zu] Job[%zu]", pList->size(), (*rJob).size()); |
| List<NS3Av3::MetaSet_T>::iterator it = pList->begin(); |
| for (size_t j = 0; j < total && it != pList->end(); j++) { |
| it++; |
| } // shift to (P1_3A_LIST_INDEX * mBurstNum) |
| for (size_t i = 0; i < (*rJob).size() && it != pList->end(); i++, it++) { |
| P1Act pAct = GET_ACT_PTR(pAct, (*rJob).edit((MUINT8)i), RET_VOID); |
| P1_LOG_META(*pAct, &(it->appMeta), "3A.Set-APP"); |
| P1_LOG_META(*pAct, &(it->halMeta), "3A.Set-HAL"); |
| // P1_LOG_META(*pAct, &(pAct->metaSet.appMeta), "3A.Act-APP"); |
| // P1_LOG_META(*pAct, &(pAct->metaSet.halMeta), "3A.Act-HAL"); |
| } |
| } |
| return; |
| } |
| #endif |
| |
| #if SUPPORT_LCS |
| MERROR P1NodeImp::lcsInit() { |
| if (mEnableLCSO) { |
| P1_TIMING_CHECK("P1:LCS-init", 10, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:LCS-init"); |
| MY_LOGI("MAKE_LcsHal +++"); |
| mpLCS = MAKE_LCSHAL_IPC(LOG_TAG, getOpenId()); |
| if (mpLCS == nullptr) { |
| MY_LOGE("mpLCS is NULL"); |
| return DEAD_OBJECT; |
| } |
| if (mpLCS->Init() != LCS_RETURN_NO_ERROR) { |
| mpLCS->DestroyInstance(LOG_TAG); |
| mpLCS = nullptr; |
| } |
| MY_LOGI("MAKE_LcsHal ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:LCS-init" |
| } |
| return OK; |
| } |
| #endif |
| |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| MVOID P1NodeImp::v4l2DeviceStart() { |
| // update dynamic info after powered on sensor |
| MY_LOGD("setDynamicSensorInfoToIPCHalSensor[+]"); |
| int err = setDynamicSensorInfoToIPCHalSensor(getOpenId()); |
| MY_LOGD("setDynamicSensorInfoToIPCHalSensor[-]"); |
| |
| if (CC_UNLIKELY(err != 0)) { |
| MY_LOGE("setDynamicSensorInfoToIPCHalSensor failed"); |
| } |
| |
| MY_LOGI("V4L2SensorWorker start +++"); |
| mpV4L2SensorMgr = std::make_shared<v4l2::V4L2SensorWorker>(getOpenId()); |
| mpV4L2SensorMgr->start(); |
| MY_LOGI("V4L2SensorWorker start ---"); |
| |
| MY_LOGI("V4L2LensMgr start +++"); |
| mpV4L2LensMgr = std::make_shared<v4l2::V4L2LensMgr>(getOpenId()); |
| mpV4L2LensMgr->start(); |
| MY_LOGI("V4L2LensMgr start ---"); |
| |
| MY_LOGI("V4L2P13ACallback start +++"); |
| mpV4L2P13ACallback = |
| std::make_shared<v4l2::V4L2P13ACallback>(getOpenId(), this); |
| mpV4L2P13ACallback->start(); |
| MY_LOGI("V4L2P13ACallback start ---"); |
| } |
| #endif |
| |
| MVOID P1NodeImp::addConfigPort(std::vector<PortInfo>* vPortInfo, |
| EImageFormat* resizer_fmt) { |
| if (mvStreamImg[STREAM_IMG_OUT_FULL] != nullptr) { |
| MINT fmt = mvStreamImg[STREAM_IMG_OUT_FULL]->getImgFormat(); |
| IImageStreamInfo::BufPlanes_t const& planes = |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getBufPlanes(); |
| PortInfo OutPort(PORT_IMGO, (EImageFormat)fmt, |
| mvStreamImg[STREAM_IMG_OUT_FULL]->getImgSize(), |
| MRect(MPoint(0, 0), mSensorParams.size), |
| P1_STRIDE(planes, 0), P1_STRIDE(planes, 1), |
| P1_STRIDE(planes, 2), |
| 0, // pureraw |
| MTRUE /*IS_RAW_FMT_PACK_FULL(fmt) packed*/, |
| 10); // packed |
| // by driver request, the PAK should be ON even if un-packed raw |
| (*vPortInfo).push_back(OutPort); |
| mConfigPort |= CONFIG_PORT_IMGO; |
| mConfigPortNum++; |
| } else if (mvStreamImg[STREAM_IMG_OUT_OPAQUE] != nullptr) { |
| PortInfo OutPort(PORT_IMGO, (EImageFormat)mRawFormat, mSensorParams.size, |
| MRect(MPoint(0, 0), mSensorParams.size), mRawStride, |
| 0 /*StrideInByte[1]*/, 0 /*StrideInByte[2]*/, |
| 0, // pureraw |
| MTRUE /*IS_RAW_FMT_PACK_FULL(mRawFormat)*/); // packed |
| // by driver request, the PAK should be ON even if un-packed raw |
| (*vPortInfo).push_back(OutPort); |
| mConfigPort |= CONFIG_PORT_IMGO; |
| mConfigPortNum++; |
| } |
| // |
| if (mvStreamImg[STREAM_IMG_OUT_RESIZE] != nullptr) { |
| IImageStreamInfo::BufPlanes_t const& planes = |
| mvStreamImg[STREAM_IMG_OUT_RESIZE]->getBufPlanes(); |
| PortInfo OutPort( |
| PORT_RRZO, |
| (EImageFormat)mvStreamImg[STREAM_IMG_OUT_RESIZE]->getImgFormat(), |
| mvStreamImg[STREAM_IMG_OUT_RESIZE]->getImgSize(), |
| MRect(MPoint(0, 0), mSensorParams.size), P1_STRIDE(planes, 0), |
| P1_STRIDE(planes, 1), P1_STRIDE(planes, 2), |
| 0, // pureraw |
| MTRUE, // packed |
| 10); // packed |
| (*vPortInfo).push_back(OutPort); |
| mConfigPort |= CONFIG_PORT_RRZO; |
| mConfigPortNum++; |
| // |
| *resizer_fmt = |
| (EImageFormat)mvStreamImg[STREAM_IMG_OUT_RESIZE]->getImgFormat(); |
| } |
| |
| if (mEnableLCSO && mvStreamImg[STREAM_IMG_OUT_LCS] != nullptr) { |
| IImageStreamInfo::BufPlanes_t const& planes = |
| mvStreamImg[STREAM_IMG_OUT_LCS]->getBufPlanes(); |
| PortInfo OutPort( |
| PORT_LCSO, |
| (EImageFormat)mvStreamImg[STREAM_IMG_OUT_LCS]->getImgFormat(), |
| mvStreamImg[STREAM_IMG_OUT_LCS]->getImgSize(), |
| MRect(MPoint(0, 0), mvStreamImg[STREAM_IMG_OUT_LCS]->getImgSize()), |
| P1_STRIDE(planes, 0), P1_STRIDE(planes, 1), P1_STRIDE(planes, 2), |
| 0, // pureraw |
| MTRUE, // packed |
| 10); |
| (*vPortInfo).push_back(OutPort); |
| mConfigPort |= CONFIG_PORT_LCSO; |
| mConfigPortNum++; |
| } |
| |
| if (mEnableRSSO && mvStreamImg[STREAM_IMG_OUT_RSS] != nullptr) { |
| IImageStreamInfo::BufPlanes_t const& planes = |
| mvStreamImg[STREAM_IMG_OUT_RSS]->getBufPlanes(); |
| PortInfo OutPort( |
| PORT_RSSO, |
| (EImageFormat)mvStreamImg[STREAM_IMG_OUT_RSS]->getImgFormat(), |
| mvStreamImg[STREAM_IMG_OUT_RSS]->getImgSize(), |
| MRect(MPoint(0, 0), mvStreamImg[STREAM_IMG_OUT_RSS]->getImgSize()), |
| P1_STRIDE(planes, 0), P1_STRIDE(planes, 1), P1_STRIDE(planes, 2), |
| 0, // pureraw |
| MTRUE); // packed |
| (*vPortInfo).push_back(OutPort); |
| mConfigPort |= CONFIG_PORT_RSSO; |
| mConfigPortNum++; |
| } |
| if (mEnableEISO) { |
| PortInfo OutPort(PORT_EISO, eImgFmt_BLOB, MSize(LMVO_MEMORY_SIZE, 1), |
| MRect(LMVO_MEMORY_SIZE, 1), LMVO_MEMORY_SIZE, |
| 0, // pPortCfg->mStrideInByte[1], |
| 0, // pPortCfg->mStrideInByte[2], |
| 0, // pureraw |
| MTRUE, |
| 10); // packed |
| |
| (*vPortInfo).push_back(OutPort); |
| mConfigPort |= CONFIG_PORT_EISO; |
| mConfigPortNum++; |
| } |
| } |
| |
| MERROR P1NodeImp::startCamIO( |
| QInitParam halCamIOinitParam, |
| MSize* binInfoSize, |
| MSize rawSize[2], |
| PipeTag* pipe_tag, |
| std::map<int, std::vector<std::shared_ptr<IImageBuffer>>>* buffers) { |
| { |
| MERROR err = OK; |
| P1_TIMING_CHECK("P1:DRV-init", 20, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-init"); |
| MY_LOGI("mpCamIO->init +++"); |
| if ((mConfigPort & CONFIG_PORT_RRZO) && (mConfigPort & CONFIG_PORT_IMGO)) { |
| *pipe_tag = kPipeTag_Out2_Tuning; |
| } else if ((mConfigPort & CONFIG_PORT_RRZO) || |
| (mConfigPort & CONFIG_PORT_IMGO)) { |
| *pipe_tag = kPipeTag_Out1_Tuning; |
| } |
| if (err < 0 || !mpCamIO || !mpCamIO->init(*pipe_tag)) { |
| MY_LOGE("hardware init fail - err:%#x mpCamIO:%p", err, mpCamIO.get()); |
| return DEAD_OBJECT; |
| } |
| MY_LOGI("mpCamIO->init ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-init" |
| } |
| MSize rawSize_l[2]; |
| MSize* pSizeProc = &rawSize_l[0]; // 0 = EPipe_PROCESSED_RAW |
| MSize* pSizePure = &rawSize_l[1]; // 1 = EPipe_PURE_RAW |
| *pSizeProc = MSize(0, 0); |
| *pSizePure = MSize(0, 0); |
| if (mConfigPort & CONFIG_PORT_EISO) { |
| buffers->emplace(PORT_EISO.index, |
| std::vector<std::shared_ptr<IImageBuffer>>{}); |
| } |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| IIPCHalSensor::DynamicInfo ipcDynamicInfo; |
| #endif |
| if (mpCamIO != nullptr) { |
| P1_TIMING_CHECK("P1:DRV-configPipe", 500, TC_W); |
| mLogInfo.setMemo(LogInfo::CP_OP_START_DRV_CFG_BGN); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-configPipe"); |
| MY_LOGI("mpCamIO->configPipe +++"); |
| if (!mpCamIO->configPipe(halCamIOinitParam, buffers)) { |
| MY_LOGE("mpCamIO->configPipe fail"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-configPipe" |
| mLogInfo.setMemo(LogInfo::CP_OP_START_DRV_CFG_END); |
| return BAD_VALUE; |
| } else { |
| MY_LOGI("mpCamIO->configPipe ---"); |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-configPipe" |
| mLogInfo.setMemo(LogInfo::CP_OP_START_DRV_CFG_END); |
| // |
| { |
| MBOOL notSupportProc = MFALSE; |
| MBOOL notSupportPure = MFALSE; |
| MUINT32 newDefType = mRawDefType; |
| MUINT32 newOption = mRawOption; |
| P1_TRACE_S_BEGIN(SLG_S, "P1:DRV-GetImgoInfo"); |
| if (mpCamIO->sendCommand(ENPipeCmd_GET_TG_OUT_SIZE, |
| (MINTPTR)(&rawSize_l), (MINTPTR)NULL, |
| (MINTPTR)NULL)) { |
| P1_TRACE_C_END(SLG_S); // "P1:DRV-GetImgoInfo" |
| if (pSizeProc->w == 0 || pSizeProc->h == 0) { |
| notSupportProc = MTRUE; |
| } |
| if (pSizePure->w == 0 || pSizePure->h == 0) { |
| notSupportPure = MTRUE; |
| } |
| } |
| if ((!notSupportProc) && (!notSupportPure)) { |
| // both Proc raw and Pure raw are supported |
| // not change the raw type setting |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| // update resolution from any RAW type is ok. |
| if (pSizePure->w != 0 && pSizePure->h != 0) { |
| ipcDynamicInfo.tg_size = *pSizePure; |
| } |
| #endif |
| } else if ((!notSupportProc) && (notSupportPure)) { |
| // only support Proc raw |
| newDefType = EPipe_PROCESSED_RAW; |
| newOption = (1 << EPipe_PROCESSED_RAW); |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| ipcDynamicInfo.tg_size = *pSizeProc; |
| #endif |
| } else if ((notSupportProc) && (!notSupportPure)) { |
| // only support Pure raw |
| newDefType = EPipe_PURE_RAW; |
| newOption = (1 << EPipe_PURE_RAW); |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| ipcDynamicInfo.tg_size = *pSizePure; |
| #endif |
| } else { |
| // not support Proc raw and Pure raw |
| MY_LOGE( |
| "Raw(%d,0x%x) Proc(%dx%d) Pure(%dx%d) " |
| "- Not Support", |
| mRawDefType, mRawOption, pSizeProc->w, pSizeProc->h, pSizePure->w, |
| pSizePure->h); |
| return BAD_VALUE; |
| } |
| MY_LOGI_IF((mRawDefType != newDefType) || (mRawOption != newOption), |
| "[RAW_TYPE] Raw(%d,0x%x) => New(%d,0x%x)" |
| "Proc(%dx%d) Pure(%dx%d)", |
| mRawDefType, mRawOption, newDefType, newOption, pSizeProc->w, |
| pSizeProc->h, pSizePure->w, pSizePure->h); |
| // |
| mRawDefType = newDefType; |
| mRawOption = newOption; |
| } |
| } |
| } |
| |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| { |
| // after p1 started, update dynamic info again (for TG selection) |
| MY_LOGD("setDynamicSensorInfoToIPCHalSensor[+]"); |
| int err = setDynamicSensorInfoToIPCHalSensor(getOpenId()); |
| MY_LOGD("setDynamicSensorInfoToIPCHalSensor[-]"); |
| if (CC_UNLIKELY(err != 0)) { |
| MY_LOGE("setDynamicSensorInfoToIPCHalSensor failed"); |
| } |
| |
| // Before update extended dynamic info, check bin_size and hbin_size, |
| // if it's 0, give it the same as tg size. |
| if (ipcDynamicInfo.bin_size.w == 0 || ipcDynamicInfo.bin_size.h == 0) { |
| ipcDynamicInfo.bin_size = ipcDynamicInfo.tg_size; |
| } |
| if (ipcDynamicInfo.hbin_size.w == 0 || ipcDynamicInfo.hbin_size.h == 0) { |
| ipcDynamicInfo.hbin_size = ipcDynamicInfo.tg_size; |
| } |
| // Update extended dynamic info too. |
| err = setDynamicInfoExToIPCHalSensor(getOpenId(), ipcDynamicInfo); |
| if (CC_UNLIKELY(err != 0)) { |
| MY_LOGE("setDynamicInfoExToIPCHalSensor failed, need check."); |
| } |
| } |
| #endif |
| |
| rawSize[0] = rawSize_l[0]; |
| rawSize[1] = rawSize_l[1]; |
| |
| return OK; |
| } |
| |
| QInitParam P1NodeImp::prepareQInitParam( |
| IHalSensor::ConfigParam* sensorCfg, |
| NS3Av3::AEInitExpoSetting_T initExpoSetting, |
| std::vector<PortInfo> vPortInfo) { |
| sensorCfg->index = (MUINT)getOpenId(); |
| sensorCfg->crop = mSensorParams.size; |
| sensorCfg->scenarioId = mSensorParams.mode; |
| sensorCfg->isBypassScenario = 0; |
| sensorCfg->isContinuous = 1; |
| sensorCfg->HDRMode = MFALSE; |
| #if (P1NODE_USING_MTK_LDVT > 0) |
| sensorCfg->framerate = 1; |
| #else |
| sensorCfg->framerate = mSensorParams.fps; |
| #endif |
| sensorCfg->twopixelOn = 0; |
| sensorCfg->debugMode = 0; |
| sensorCfg->exposureTime = initExpoSetting.u4Eposuretime; |
| sensorCfg->gain = initExpoSetting.u4AfeGain; |
| sensorCfg->exposureTime_se = initExpoSetting.u4Eposuretime_se; |
| sensorCfg->gain_se = initExpoSetting.u4AfeGain_se; |
| |
| std::vector<IHalSensor::ConfigParam> vSensorCfg; |
| vSensorCfg.push_back(*sensorCfg); // only insert once |
| |
| // |
| MBOOL bDynamicRawType = MTRUE; // true:[ON] ; false:[OFF] |
| QInitParam halCamIOinitParam(0, /*sensor test pattern */ |
| vSensorCfg, vPortInfo, bDynamicRawType); |
| halCamIOinitParam.m_IQlv = mCfg.mQualityLv; |
| // halCamIOinitParam.m_Func.Bits.SensorNum = mCfg.mSensorNum; |
| halCamIOinitParam.m_pipelinebitdepth = (E_CAM_PipelineBitDepth_SEL)mPipeBit; |
| halCamIOinitParam.m_DynamicTwin = mIsDynamicTwinEn; |
| // halCamIOinitParam.m_DropCB = doNotifyDropframe; |
| halCamIOinitParam.mSensorFormatOrder = mSensorFormatOrder; |
| halCamIOinitParam.m_returnCookie = this; |
| // enable frame sync |
| if (mEnableFrameSync) { |
| MY_LOGI("P1 node(%d) is in synchroized mode", getOpenId()); |
| halCamIOinitParam.m_bN3D = MTRUE; |
| } else { |
| halCamIOinitParam.m_bN3D = MFALSE; |
| } |
| |
| return halCamIOinitParam; |
| } |
| |
| MERROR P1NodeImp::lmvInit(MSize sensorSize, MSize rrzoSize) { |
| if (mEnableEISO) { |
| P1_TIMING_CHECK("P1:LMV-init", 20, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:LMV-init"); |
| if (IS_LMV(mpConnectLMV)) { |
| MINT32 mode = EIS::EisInfo::getMode(mPackedEisInfo); |
| MINT32 factor = EIS::EisInfo::getFactor(mPackedEisInfo); |
| MY_LOGD("mpConnectLMV->init+"); |
| if (MFALSE == mpConnectLMV->init(mode, factor, sensorSize, rrzoSize)) { |
| MY_LOGE("ConnectLMV create fail"); |
| return BAD_VALUE; |
| } |
| } |
| P1_TRACE_C_END(SLG_S); // "P1:LMV-init" |
| } |
| return OK; |
| } |
| |
| #if SUPPORT_3A |
| MERROR P1NodeImp::getAEInitExpoSetting( |
| NS3Av3::AEInitExpoSetting_T* initExpoSetting) { |
| P1_TIMING_CHECK("P1:3A-create-GetAEInitExpoSetting", 10, TC_W); |
| P1_TRACE_S_BEGIN(SLG_S, "P1:3A-create-GetAEInitExpoSetting"); |
| MY_LOGI("MAKE_Hal3A +++"); |
| MAKE_Hal3A( |
| mp3A, [](NS3Av3::IHal3A* p) { p->destroyInstance(LOG_TAG); }, getOpenId(), |
| LOG_TAG); |
| if (mp3A == nullptr) { |
| MY_LOGE("mp3A is NULL"); |
| return DEAD_OBJECT; |
| } |
| MY_LOGI("MAKE_Hal3A ---"); |
| mp3A->send3ACtrl(NS3Av3::E3ACtrl_GetAEInitExpoSetting, |
| (MINTPTR)initExpoSetting, 0); |
| MY_LOGI( |
| "GetAEInitExpoSetting: u4Eposuretime(le:%d/se:%d) " |
| "u4AfeGain(le:%d/se:%d)", |
| (*initExpoSetting).u4Eposuretime, (*initExpoSetting).u4Eposuretime_se, |
| (*initExpoSetting).u4AfeGain, (*initExpoSetting).u4AfeGain_se); |
| P1_TRACE_C_END(SLG_S); // "P1:3A-create-GetAEInitExpoSetting" |
| return OK; |
| } |
| #endif |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::generateCtrlQueue(std::vector<NS3Av3::MetaSet_T*>* rQue, |
| P1QueJob* rJob) { |
| for (size_t j = 0; j < (*rJob).size(); j++) { |
| if ((*rJob).edit(j).ptr() != nullptr) { |
| (*rQue).push_back(&((*rJob).edit(j).ptr()->metaSet)); |
| } |
| } |
| // |
| if (mMetaLogOp > 0 && (*rQue).size() > 0 && |
| (*rQue).size() == (*rJob).size()) { |
| MY_LOGI("LogMeta Que[%zu] Job[%zu]", (*rQue).size(), (*rJob).size()); |
| std::vector<NS3Av3::MetaSet_T*>::iterator it = (*rQue).begin(); |
| for (size_t i = 0; i < (*rJob).size() && it != (*rQue).end(); i++, it++) { |
| P1Act pAct = GET_ACT_PTR(pAct, (*rJob).edit((MUINT8)i), RET_VOID); |
| P1_LOG_META(*pAct, &((*it)->appMeta), "3A.Set-APP"); |
| P1_LOG_META(*pAct, &((*it)->halMeta), "3A.Set-HAL"); |
| } |
| } |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::createAction(P1QueAct* rAct, |
| std::shared_ptr<IPipelineFrame> appFrame, |
| REQ_TYPE eType) { |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| // create queue act |
| // MUINT32 newNum = get_and_increase_magicnum(); |
| NS3Av3::MetaSet_T* metaInfo = &(act->metaSet); |
| IMetadata* pAppMeta = &(act->metaSet.appMeta); |
| IMetadata* pHalMeta = &(act->metaSet.halMeta); |
| if (pAppMeta == nullptr) { |
| MY_LOGE("pAppMeta == NULL"); |
| } |
| act->metaSet.PreSetKey = rAct->id(); |
| // |
| MINT32 meta_raw_type = (MINT32)mRawDefType; |
| MBOOL meta_raw_exist = MFALSE; |
| MBOOL meta_zsl_req = MFALSE; |
| // |
| P1_TRACE_F_BEGIN(SLG_I, "P1:create|Fnum:%d Rnum:%d", P1GET_FRM_NUM(appFrame), |
| P1GET_REQ_NUM(appFrame)); |
| MINT32 meta_ZslEn = P1_META_GENERAL_EMPTY_INT; |
| MINT32 meta_CapIntent = P1_META_GENERAL_EMPTY_INT; |
| MINT32 meta_RawType = P1_META_GENERAL_EMPTY_INT; |
| MINT32 meta_TgNum = P1_META_GENERAL_EMPTY_INT; |
| MINT32 meta_QualityCtrl = P1_META_GENERAL_EMPTY_INT; |
| MINT32 meta_FmtImgo = P1_META_GENERAL_EMPTY_INT; // eImgFmt_UNKNOWN |
| MINT32 meta_FmtRrzo = P1_META_GENERAL_EMPTY_INT; // eImgFmt_UNKNOWN |
| // |
| if (appFrame != nullptr) { |
| if (CC_UNLIKELY(eType != REQ_TYPE_UNKNOWN)) { |
| MY_LOGE("Type-Mismatching (%d) on (%d, %d)", eType, |
| P1GET_FRM_NUM(appFrame), P1GET_REQ_NUM(appFrame)); |
| return; |
| } |
| if (act->appFrame != appFrame) { // act->appFrame == NULL |
| act->appFrame = appFrame; |
| act->frmNum = appFrame->getFrameNo(); |
| act->reqNum = appFrame->getRequestNo(); |
| act->mapFrameStream(); |
| MY_LOGI("CreateAct(%d,%d) assign frame", act->frmNum, act->reqNum); |
| } |
| // |
| P1_TRACE_S_BEGIN(SLG_O, "createMeta"); |
| if (mvStreamMeta[STREAM_META_IN_APP] != nullptr) { |
| if (OK == act->frameMetadataGet(STREAM_META_IN_APP, pAppMeta)) { |
| P1_LOG_META(*act, pAppMeta, "RequestIn-APP"); |
| } else { |
| MY_LOGI("can not lock the app metadata"); |
| pAppMeta = nullptr; |
| } |
| } |
| if (mvStreamMeta[STREAM_META_IN_HAL] != nullptr) { |
| if (OK == act->frameMetadataGet(STREAM_META_IN_HAL, pHalMeta)) { |
| P1_LOG_META(*act, pHalMeta, "RequestIn-HAL"); |
| } else { |
| MY_LOGI("can not lock the hal metadata"); |
| pHalMeta = nullptr; |
| } |
| } |
| P1_TRACE_C_END(SLG_O); // "createMeta" |
| // check info from APP meta |
| if (pAppMeta != nullptr) { |
| MUINT8 zsl_en = MTK_CONTROL_ENABLE_ZSL_FALSE; |
| if (tryGetMetadata<MUINT8>(pAppMeta, MTK_CONTROL_ENABLE_ZSL, &zsl_en)) { |
| meta_ZslEn = zsl_en; |
| } |
| MINT32 patternMode = 0; |
| if (tryGetMetadata<MINT32>(pAppMeta, MTK_SENSOR_TEST_PATTERN_MODE, |
| &patternMode)) { |
| mMeta_PatMode = patternMode; |
| MY_LOGD("p1 createAction pattern mode %d", mMeta_PatMode); |
| } |
| MUINT8 cap_intent = MTK_CONTROL_CAPTURE_INTENT_CUSTOM; |
| if (tryGetMetadata<MUINT8>(pAppMeta, MTK_CONTROL_CAPTURE_INTENT, |
| &cap_intent)) { |
| meta_CapIntent = cap_intent; |
| } |
| if (zsl_en == MTK_CONTROL_ENABLE_ZSL_TRUE && |
| cap_intent == MTK_CONTROL_CAPTURE_INTENT_STILL_CAPTURE |
| #if 1 // check-bypass-request |
| && appFrame->IsReprocessFrame() |
| #endif |
| ) { |
| meta_zsl_req = MTRUE; |
| } |
| } |
| // check info from HAL meta |
| if (pHalMeta != nullptr) { |
| MINT32 raw_type = meta_raw_type; |
| if (tryGetMetadata<MINT32>(pHalMeta, MTK_P1NODE_RAW_TYPE, &raw_type)) { |
| meta_RawType = raw_type; |
| MY_LOGD("raw type set from outside %d", raw_type); |
| if (meta_raw_type != raw_type) { |
| MY_LOGI("Metadata-Raw(%d) - Config-Raw(%d)(%d-0x%x)", raw_type, |
| meta_raw_type, mRawDefType, mRawOption); |
| } |
| if ((mRawOption & (MUINT32)(1 << raw_type)) > 0) { |
| meta_raw_type = raw_type; |
| meta_raw_exist = MTRUE; |
| } else { |
| MY_LOGI( |
| "raw type (%d) set from outside, but not accept " |
| "RawOption(0x%x)", |
| raw_type, mRawOption); |
| } |
| } |
| if (IS_LMV(mpConnectLMV) && mpConnectLMV->checkSwitchOut(pHalMeta)) { |
| act->uniSwitchState = UNI_SWITCH_STATE_REQ; |
| } |
| // for Twin Switch TG Number control |
| if (mIsDynamicTwinEn) { |
| MINT32 tg_num = MTK_P1_TWIN_SWITCH_NONE; |
| if (tryGetMetadata<MINT32>(pHalMeta, MTK_P1NODE_TWIN_SWITCH, &tg_num)) { |
| meta_TgNum = tg_num; |
| if (tg_num != MTK_P1_TWIN_SWITCH_NONE) { |
| act->tgSwitchState = TG_SWITCH_STATE_REQ; |
| switch (tg_num) { |
| case MTK_P1_TWIN_SWITCH_ONE_TG: |
| act->tgSwitchNum = 1; |
| break; |
| case MTK_P1_TWIN_SWITCH_TWO_TG: |
| act->tgSwitchNum = 2; |
| break; |
| default: |
| MY_LOGI("check MTK_P1NODE_TWIN_SWITCH %d", tg_num); |
| break; |
| } |
| } |
| } |
| } |
| // for Standby Mode control |
| if (mpHwStateCtrl != nullptr) { |
| act->ctrlSensorStatus = mpHwStateCtrl->checkReceiveFrame(pHalMeta); |
| } |
| // for Quality Switch control |
| if (mpRegisterNotify != nullptr) { |
| MINT32 quality_ctrl = MTK_P1_RESIZE_QUALITY_SWITCH_NONE; |
| act->qualitySwitchState = QUALITY_SWITCH_STATE_NONE; |
| if (tryGetMetadata<MINT32>(pHalMeta, MTK_P1NODE_RESIZE_QUALITY_SWITCH, |
| &quality_ctrl)) { |
| meta_QualityCtrl = quality_ctrl; |
| if (getQualitySwitching() && |
| quality_ctrl != MTK_P1_RESIZE_QUALITY_SWITCH_NONE) { |
| act->qualitySwitchState = QUALITY_SWITCH_STATE_DONE_ILLEGAL; |
| } else { |
| switch (quality_ctrl) { |
| case MTK_P1_RESIZE_QUALITY_SWITCH_H_H: |
| act->qualitySwitchState = QUALITY_SWITCH_STATE_REQ_H_H; |
| break; |
| case MTK_P1_RESIZE_QUALITY_SWITCH_H_L: |
| act->qualitySwitchState = QUALITY_SWITCH_STATE_REQ_H_L; |
| break; |
| case MTK_P1_RESIZE_QUALITY_SWITCH_L_H: |
| act->qualitySwitchState = QUALITY_SWITCH_STATE_REQ_L_H; |
| break; |
| case MTK_P1_RESIZE_QUALITY_SWITCH_L_L: |
| act->qualitySwitchState = QUALITY_SWITCH_STATE_REQ_L_L; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| if (act->qualitySwitchState != QUALITY_SWITCH_STATE_NONE) { |
| E_CamIQLevel CamLvA = eCamIQ_MAX; |
| E_CamIQLevel CamLvB = eCamIQ_MAX; |
| if (mpCamIO != nullptr && |
| mpCamIO->sendCommand(ENPipeCmd_GET_QUALITY, (MINTPTR)NULL, |
| (MINTPTR)&CamLvA, (MINTPTR)&CamLvB)) { |
| MBOOL ignore = MFALSE; |
| switch (quality_ctrl) { |
| case MTK_P1_RESIZE_QUALITY_SWITCH_H_H: |
| if (CamLvA == eCamIQ_H && CamLvB == eCamIQ_H) { |
| ignore = MTRUE; |
| } |
| break; |
| case MTK_P1_RESIZE_QUALITY_SWITCH_H_L: |
| if (CamLvA == eCamIQ_H && CamLvB == eCamIQ_L) { |
| ignore = MTRUE; |
| } |
| break; |
| case MTK_P1_RESIZE_QUALITY_SWITCH_L_H: |
| if (CamLvA == eCamIQ_L && CamLvB == eCamIQ_H) { |
| ignore = MTRUE; |
| } |
| break; |
| case MTK_P1_RESIZE_QUALITY_SWITCH_L_L: |
| if (CamLvA == eCamIQ_L && CamLvB == eCamIQ_L) { |
| ignore = MTRUE; |
| } |
| break; |
| default: |
| break; |
| } |
| if (ignore) { |
| act->qualitySwitchState = QUALITY_SWITCH_STATE_DONE_IGNORE; |
| } |
| } |
| } |
| if ((act->qualitySwitchState & QUALITY_SWITCH_STATE_REQ_NON) > 0) { |
| setQualitySwitching(MTRUE); |
| } |
| } |
| |
| if (tryGetMetadata<MINT32>(pHalMeta, MTK_HAL_REQUEST_IMG_IMGO_FORMAT, |
| &(act->mReqFmt_Imgo))) { |
| meta_FmtImgo = act->mReqFmt_Imgo; |
| MY_LOGI("MTK_REQUEST_IMG_IMGO_FORMAT : 0x%x", act->mReqFmt_Imgo); |
| } |
| |
| if (tryGetMetadata<MINT32>(pHalMeta, MTK_HAL_REQUEST_IMG_RRZO_FORMAT, |
| &(act->mReqFmt_Rrzo))) { |
| meta_FmtRrzo = act->mReqFmt_Rrzo; |
| MY_LOGI("MTK_REQUEST_IMG_RRZO_FORMAT : 0x%x", act->mReqFmt_Rrzo); |
| } |
| } |
| // |
| if (meta_zsl_req) { |
| act->reqType = REQ_TYPE_ZSL; |
| } else if (act->streamBufImg[STREAM_IMG_IN_YUV].bExist) { |
| act->reqType = REQ_TYPE_YUV; |
| } else if (act->streamBufImg[STREAM_IMG_IN_OPAQUE].bExist) { |
| act->reqType = REQ_TYPE_REDO; |
| } else { |
| act->reqType = REQ_TYPE_NORMAL; |
| if (IS_PORT(CONFIG_PORT_IMGO, mConfigPort) && |
| act->streamBufImg[STREAM_IMG_OUT_OPAQUE].bExist) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_FULL_OPAQUE); |
| } |
| if (IS_PORT(CONFIG_PORT_IMGO, mConfigPort) && |
| act->streamBufImg[STREAM_IMG_OUT_FULL].bExist) { |
| if (meta_raw_type == EPipe_PROCESSED_RAW) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_FULL_PROC); |
| } else { |
| act->reqOutSet |= REQ_SET(REQ_OUT_FULL_PURE); |
| } |
| } |
| if (IS_PORT(CONFIG_PORT_RRZO, mConfigPort) && |
| act->streamBufImg[STREAM_IMG_OUT_RESIZE].bExist) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_RESIZER); |
| } |
| if (IS_PORT(CONFIG_PORT_LCSO, mConfigPort) && |
| act->streamBufImg[STREAM_IMG_OUT_LCS].bExist) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_LCSO); |
| } |
| if (IS_PORT(CONFIG_PORT_RSSO, mConfigPort) && |
| act->streamBufImg[STREAM_IMG_OUT_RSS].bExist) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_RSSO); |
| } |
| } |
| } else { |
| switch (eType) { |
| case REQ_TYPE_INITIAL: |
| case REQ_TYPE_PADDING: |
| case REQ_TYPE_DUMMY: |
| act->reqType = eType; |
| break; |
| default: // REQ_TYPE_UNKNOWN/REQ_TYPE_NORMAL/REQ_TYPE_REDO/REQ_TYPE_YUV |
| MY_LOGE("Type-Mismatching (%d)", eType); |
| return; |
| } |
| pAppMeta = nullptr; |
| pHalMeta = nullptr; |
| if (act->reqType == |
| REQ_TYPE_INITIAL) { // using pool buffer only in initial act |
| if (IS_PORT(CONFIG_PORT_IMGO, mConfigPort) && |
| mpStreamPool_full != nullptr) { |
| if (meta_raw_type == EPipe_PROCESSED_RAW) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_FULL_PROC); |
| } else { |
| act->reqOutSet |= REQ_SET(REQ_OUT_FULL_PURE); |
| } |
| } |
| if (IS_PORT(CONFIG_PORT_RRZO, mConfigPort) && |
| mpStreamPool_resizer != nullptr) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_RESIZER); |
| } |
| if (IS_PORT(CONFIG_PORT_LCSO, mConfigPort) && |
| mpStreamPool_lcso != nullptr) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_LCSO); |
| } |
| if (IS_PORT(CONFIG_PORT_RSSO, mConfigPort) && |
| mpStreamPool_rsso != nullptr) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_RSSO); |
| } |
| } |
| } |
| // |
| act->fullRawType = meta_raw_type; |
| if (act->reqType == REQ_TYPE_NORMAL) { |
| #if 1 // add raw type to hal meta |
| if (act->reqType == REQ_TYPE_NORMAL && !meta_raw_exist) { |
| IMetadata::IEntry entryRawType(MTK_P1NODE_RAW_TYPE); |
| entryRawType.push_back(meta_raw_type, Type2Type<MINT32>()); |
| metaInfo->halMeta.update(MTK_P1NODE_RAW_TYPE, entryRawType); |
| } |
| #endif |
| } |
| // |
| if (act->reqType == REQ_TYPE_NORMAL || act->reqType == REQ_TYPE_INITIAL || |
| act->reqType == REQ_TYPE_PADDING || act->reqType == REQ_TYPE_DUMMY) { |
| if (IS_PORT(CONFIG_PORT_IMGO, mConfigPort) && |
| (0 == (IS_OUT(REQ_OUT_FULL_PROC, act->reqOutSet) || |
| IS_OUT(REQ_OUT_FULL_PURE, act->reqOutSet) || |
| IS_OUT(REQ_OUT_FULL_OPAQUE, act->reqOutSet)))) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_FULL_STUFF); |
| } |
| if (IS_PORT(CONFIG_PORT_RRZO, mConfigPort) && |
| (0 == IS_OUT(REQ_OUT_RESIZER, act->reqOutSet))) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_RESIZER_STUFF); |
| } |
| if (IS_PORT(CONFIG_PORT_LCSO, mConfigPort) && |
| (0 == IS_OUT(REQ_OUT_LCSO, act->reqOutSet))) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_LCSO_STUFF); |
| } |
| if (IS_PORT(CONFIG_PORT_RSSO, mConfigPort) && |
| (0 == IS_OUT(REQ_OUT_RSSO, act->reqOutSet))) { |
| act->reqOutSet |= REQ_SET(REQ_OUT_RSSO_STUFF); |
| } |
| // |
| prepareCropInfo(rAct, pAppMeta, pHalMeta, |
| PREPARE_CROP_PHASE_RECEIVE_CREATE); |
| act->exeState = EXE_STATE_REQUESTED; |
| } else if (act->reqType == REQ_TYPE_REDO || act->reqType == REQ_TYPE_YUV || |
| act->reqType == REQ_TYPE_ZSL) { |
| act->exeState = EXE_STATE_DONE; |
| } |
| // |
| // mTagReq.set(rAct.id()); // set number while act register |
| // |
| if (1 <= mLogLevelI) { // P1_LOGI(1) |
| std::string info(act->msg); |
| act->msg.clear(); |
| act->msg += base::StringPrintf( |
| "[P1::REQ]" P1INFO_ACT_STR |
| " [META ze:%d ci:%d rt:%d tn:%d qc:%d fi:%d fr:%d] [%s][%d] ", |
| P1INFO_ACT_VAR(*act), meta_ZslEn, meta_CapIntent, meta_RawType, |
| meta_TgNum, meta_QualityCtrl, meta_FmtImgo, meta_FmtRrzo, |
| (appFrame != nullptr) ? "New-Request" : "New-Dummy", eType); |
| act->msg += info; |
| if ((eType != REQ_TYPE_UNKNOWN) || // if the eType is assigned, it should |
| // be an internal act, |
| (EN_INIT_REQ_RUN && |
| mInitReqCnt < mInitReqNum)) { // print the string since no more |
| // message appending |
| P1_TRACE_F_BEGIN(SLG_PFL, |
| "P1::REQ_LOG|Mnum:%d SofIdx:%d Fnum:%d " |
| "Rnum:%d FlushSet:0x%x", |
| act->magicNum, act->sofIdx, act->frmNum, act->reqNum, |
| act->flushSet); |
| P1_LOGI(1, "%s", act->msg.c_str()); |
| P1_TRACE_C_END(SLG_PFL); // "P1::REQ_LOG" |
| } |
| } |
| // |
| P1_TRACE_C_END(SLG_I); // "P1:create" |
| // |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::onProcessResult(P1QueAct* rAct, |
| QBufInfo const& deqBuf, |
| NS3Av3::MetaSet_T const& result3A, |
| IMetadata const& resultAppend, |
| MUINT32 const index) { |
| FUNCTION_IN; |
| // |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| // |
| P1_TRACE_F_BEGIN(SLG_I, "P1:result|Mnum:%d SofIdx:%d Fnum:%d Rnum:%d", |
| act->magicNum, act->sofIdx, act->frmNum, act->reqNum); |
| // |
| if (act->appFrame != 0) { |
| if ((mvStreamMeta[STREAM_META_OUT_APP] != nullptr) && |
| (mvStreamMeta[STREAM_META_OUT_HAL] != nullptr)) { |
| // APP out Meta Stream |
| IMetadata outAppMetadata; |
| generateAppMeta(rAct, result3A, deqBuf, &outAppMetadata, index); |
| if ((IS_OUT(REQ_OUT_FULL_OPAQUE, act->reqOutSet)) && |
| (act->streamBufImg[STREAM_IMG_OUT_OPAQUE].spImgBuf != nullptr) && |
| (!IS_EXP(EXP_EVT_NOBUF_IMGO, act->expRec))) { |
| // app metadata index |
| IMetadata appTagIndex; |
| generateAppTagIndex(&outAppMetadata, &appTagIndex); |
| std::shared_ptr<IImageBufferHeap> pImageBufferHeap = |
| act->streamBufImg[STREAM_IMG_OUT_OPAQUE] |
| .spImgBuf->getImageBufferHeap(); |
| MERROR status = OpaqueReprocUtil::setAppMetadataToHeap(pImageBufferHeap, |
| &appTagIndex); |
| MY_LOGD("setAppMetadataToHeap (%d)", status); |
| } |
| // |
| // HAL out Meta Stream |
| IMetadata inHalMetadata; |
| IMetadata outHalMetadata; |
| if (OK != act->frameMetadataGet(STREAM_META_IN_HAL, &inHalMetadata)) { |
| MY_LOGW("cannot get in-hal-metadata"); |
| } |
| generateHalMeta(rAct, result3A, deqBuf, resultAppend, inHalMetadata, |
| &outHalMetadata, index); |
| if ((IS_OUT(REQ_OUT_FULL_OPAQUE, act->reqOutSet)) && |
| (act->streamBufImg[STREAM_IMG_OUT_OPAQUE].spImgBuf != nullptr) && |
| (!IS_EXP(EXP_EVT_NOBUF_IMGO, act->expRec))) { |
| std::shared_ptr<IImageBufferHeap> pImageBufferHeap = |
| act->streamBufImg[STREAM_IMG_OUT_OPAQUE] |
| .spImgBuf->getImageBufferHeap(); |
| MERROR status = OpaqueReprocUtil::setHalMetadataToHeap(pImageBufferHeap, |
| &outHalMetadata); |
| MY_LOGD("setHalMetadataToHeap (%d)", status); |
| if ((IS_OUT(REQ_OUT_LCSO, act->reqOutSet)) && |
| (act->streamBufImg[STREAM_IMG_OUT_LCS].spImgBuf != nullptr)) { |
| MERROR status = OpaqueReprocUtil::setLcsoImageToHeap( |
| pImageBufferHeap, act->streamBufImg[STREAM_IMG_OUT_LCS].spImgBuf); |
| MY_LOGD("setLcsoImageToHeap (%d)", status); |
| } |
| } |
| // |
| MBOOL isChange = MFALSE; |
| attemptCtrlReadout(rAct, &outAppMetadata, &outHalMetadata, &isChange); |
| // |
| if (mspSyncHelper != nullptr) { |
| IMetadata ctrlMeta; |
| act->frameMetadataGet(STREAM_META_IN_HAL, &ctrlMeta); |
| MBOOL res = mspSyncHelper->syncResultCheck(getOpenId(), &ctrlMeta, |
| &outHalMetadata); |
| if (!res) { |
| act->setFlush(FLUSH_MIS_SYNC); |
| MY_LOGI("SyncHelper flush this request (%d)" P1INFO_ACT_STR, res, |
| P1INFO_ACT_VAR(*act)); |
| } |
| } |
| // |
| if (OK != act->frameMetadataGet(STREAM_META_OUT_APP, nullptr, MTRUE, |
| &outAppMetadata)) { |
| MY_LOGW("cannot write out-app-metadata"); |
| } else { |
| P1_LOG_META(*act, &outAppMetadata, "ResultOut-APP"); |
| } |
| if (OK != act->frameMetadataGet(STREAM_META_OUT_HAL, nullptr, MTRUE, |
| &outHalMetadata)) { |
| MY_LOGW("cannot write out-hal-metadata"); |
| } else { |
| P1_LOG_META(*act, &outHalMetadata, "ResultOut-HAL"); |
| } |
| } else { |
| MY_LOGW("STREAM_META_OUT not exist - APP(%d) HAL(%d)", |
| (mvStreamMeta[STREAM_META_OUT_APP] != nullptr) ? MTRUE : MFALSE, |
| (mvStreamMeta[STREAM_META_OUT_HAL] != nullptr) ? MTRUE : MFALSE); |
| } |
| // |
| checkBufferDumping(rAct); |
| } |
| // |
| #if 1 // trigger only at the end of this job |
| onReturnFrame( |
| rAct, FLUSH_NONEED, |
| (IS_BURST_OFF || (index == (MUINT32)(mBurstNum - 1))) ? MTRUE : MFALSE); |
| /* DO NOT use this P1QueAct after onReturnFrame() */ |
| #else |
| onReturnFrame(rAct, FLUSH_NONEED, MTRUE); |
| /* DO NOT use this P1QueAct after onReturnFrame() */ |
| #endif |
| // |
| P1_TRACE_C_END(SLG_I); // "P1:result" |
| // |
| FUNCTION_OUT; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::processRedoFrame(P1QueAct* rAct) { |
| FUNCTION_IN; |
| // |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| // |
| if (act->getFlush()) { |
| MY_LOGD("need to flush, skip frame processing"); |
| return; |
| } |
| IMetadata appMeta; |
| IMetadata halMeta; |
| std::shared_ptr<IImageBuffer> imgBuf; |
| std::shared_ptr<IImageBuffer> imgBuf_lcso; |
| // |
| if (OK != act->frameImageGet(STREAM_IMG_IN_OPAQUE, &imgBuf) || |
| OK != act->frameImageGet(STREAM_IMG_OUT_LCS, &imgBuf_lcso)) { |
| MY_LOGE("Can not get in-opaque/lcso buffer from frame"); |
| } else { |
| std::shared_ptr<IImageBufferHeap> pHeap = imgBuf->getImageBufferHeap(); |
| IMetadata appMetaTagIndex; |
| if (OK == |
| OpaqueReprocUtil::getAppMetadataFromHeap(pHeap, &appMetaTagIndex)) { |
| // get the input of app metadata |
| IMetadata metaInApp; |
| if (OK != act->frameMetadataGet(STREAM_META_IN_APP, &metaInApp)) { |
| MY_LOGW("cannot get in-app-metadata"); |
| } |
| // get p1node's tags from opaque buffer |
| IMetadata::IEntry entryTagIndex = |
| appMetaTagIndex.entryFor(MTK_P1NODE_METADATA_TAG_INDEX); |
| for (MUINT i = 0; i < entryTagIndex.count(); i++) { |
| MUINT32 tag = entryTagIndex.itemAt( |
| i, Type2Type<MINT32>()); // get Tag from entryTagIndex |
| // update entry from metaInApp to appMeta |
| IMetadata::IEntry entryInApp = metaInApp.entryFor(tag); |
| appMeta.update(tag, entryInApp); |
| } |
| // Workaround: do not return the duplicated key for YUV reprocessing |
| appMeta.remove(MTK_JPEG_THUMBNAIL_SIZE); |
| appMeta.remove(MTK_JPEG_ORIENTATION); |
| if (OK != act->frameMetadataGet(STREAM_META_OUT_APP, nullptr, MTRUE, |
| &appMeta)) { |
| MY_LOGW("cannot write out-app-metadata"); |
| } |
| } else { |
| MY_LOGW("Can not get app meta from in-opaque buffer"); |
| } |
| if (OK == OpaqueReprocUtil::getHalMetadataFromHeap(pHeap, &halMeta)) { |
| IMetadata::IEntry entry(MTK_HAL_REQUEST_REQUIRE_EXIF); |
| entry.push_back(1, Type2Type<MUINT8>()); |
| halMeta.update(entry.tag(), entry); |
| if (OK != act->frameMetadataGet(STREAM_META_OUT_HAL, nullptr, MTRUE, |
| &halMeta)) { |
| MY_LOGW("cannot write out-hal-metadata"); |
| } |
| } else { |
| MY_LOGW("Can not get hal meta from in-opaque buffer"); |
| } |
| if (OK == OpaqueReprocUtil::getLcsoImageFromHeap(pHeap, imgBuf_lcso)) { |
| act->frameImagePut(STREAM_IMG_OUT_LCS); |
| } else { |
| MY_LOGW("Can not get lcso image from in-opaque buffer"); |
| } |
| } |
| // |
| FUNCTION_OUT; |
| // |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::processYuvFrame(P1QueAct* rAct) { |
| FUNCTION_IN; |
| // |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| // |
| if (act->getFlush()) { |
| MY_LOGD("need to flush, skip frame processing"); |
| return; |
| } |
| IMetadata inAppMetadata; |
| IMetadata outAppMetadata; |
| IMetadata inHalMetadata; |
| IMetadata outHalMetadata; |
| MINT64 timestamp = 0; |
| MFLOAT aperture = (0.0f); |
| MFLOAT focallength = (0.0f); |
| MINT64 exposure = 0; |
| MINT32 iso = 0; |
| MINT32 iso_boost = 0; |
| MINT64 duration = 0; |
| MUINT8 edge = MTK_EDGE_MODE_OFF; |
| MUINT8 noise = MTK_NOISE_REDUCTION_MODE_OFF; |
| MFLOAT factor = (1.0f); |
| // APP in Meta Stream |
| if (OK != act->frameMetadataGet(STREAM_META_IN_APP, &inAppMetadata)) { |
| MY_LOGW("cannot get in-app-metadata"); |
| } else { |
| // outAppMetadata = inAppMetadata; // copy all from in-app to out-app |
| if (tryGetMetadata<MINT64>(&inAppMetadata, MTK_SENSOR_TIMESTAMP, |
| ×tamp)) { |
| MY_LOGD("timestamp from in-app %" PRId64, timestamp); |
| } else { |
| MY_LOGI("cannot find timestamp from in-app"); |
| timestamp = 0; |
| } |
| // |
| if (tryGetMetadata<MFLOAT>(&inAppMetadata, MTK_LENS_APERTURE, &aperture)) { |
| MY_LOGD1("aperture from in-app %f", aperture); |
| if (!trySetMetadata<MFLOAT>(&outAppMetadata, MTK_LENS_APERTURE, |
| aperture)) { |
| MY_LOGW("cannot update MTK_LENS_APERTURE"); |
| } |
| } else { |
| MY_LOGI("cannot find aperture from in-app"); |
| aperture = (0.0f); |
| } |
| if (tryGetMetadata<MFLOAT>(&inAppMetadata, MTK_LENS_FOCAL_LENGTH, |
| &focallength)) { |
| MY_LOGD1("focallength from in-app %f", focallength); |
| if (!trySetMetadata<MFLOAT>(&outAppMetadata, MTK_LENS_FOCAL_LENGTH, |
| focallength)) { |
| MY_LOGW("cannot update MTK_LENS_FOCAL_LENGTH"); |
| } |
| } else { |
| MY_LOGI("cannot find focallength from in-app"); |
| focallength = (0.0f); |
| } |
| if (tryGetMetadata<MINT64>(&inAppMetadata, MTK_SENSOR_EXPOSURE_TIME, |
| &exposure)) { |
| MY_LOGD1("exposure from in-app %" PRId64, exposure); |
| if (!trySetMetadata<MINT64>(&outAppMetadata, MTK_SENSOR_EXPOSURE_TIME, |
| exposure)) { |
| MY_LOGW("cannot update MTK_SENSOR_EXPOSURE_TIME"); |
| } |
| } else { |
| MY_LOGI("cannot find exposure from in-app"); |
| exposure = 0; |
| } |
| if (tryGetMetadata<MINT32>(&inAppMetadata, MTK_SENSOR_SENSITIVITY, &iso)) { |
| MY_LOGD1("iso from in-app %" PRId32, iso); |
| if (!trySetMetadata<MINT32>(&outAppMetadata, MTK_SENSOR_SENSITIVITY, |
| iso)) { |
| MY_LOGW("cannot update MTK_SENSOR_SENSITIVITY"); |
| } |
| } else { |
| MY_LOGI("cannot find iso from in-app"); |
| iso = 0; |
| } |
| if (tryGetMetadata<MINT32>(&inAppMetadata, |
| MTK_CONTROL_POST_RAW_SENSITIVITY_BOOST, |
| &iso_boost)) { |
| MY_LOGD1("iso boost from in-app %" PRId32, iso_boost); |
| if (!trySetMetadata<MINT32>(&outAppMetadata, |
| MTK_CONTROL_POST_RAW_SENSITIVITY_BOOST, |
| iso_boost)) { |
| MY_LOGW("cannot update MTK_CONTROL_POST_RAW_SENSITIVITY_BOOST"); |
| } |
| } else { |
| MY_LOGI("cannot find iso boost from in-app"); |
| iso_boost = 0; |
| } |
| if (tryGetMetadata<MINT64>(&inAppMetadata, MTK_SENSOR_FRAME_DURATION, |
| &duration)) { |
| MY_LOGD1("duration from in-app %" PRId64, duration); |
| if (!trySetMetadata<MINT64>(&outAppMetadata, MTK_SENSOR_FRAME_DURATION, |
| duration)) { |
| MY_LOGW("cannot update MTK_SENSOR_FRAME_DURATION"); |
| } |
| } else { |
| MY_LOGI("cannot find duration from in-app"); |
| duration = 0; |
| } |
| |
| // |
| if (tryGetMetadata<MUINT8>(&inAppMetadata, MTK_EDGE_MODE, &edge)) { |
| MY_LOGD1("MTK_EDGE_MODE from in-app %d", edge); |
| if (!trySetMetadata<MUINT8>(&outAppMetadata, MTK_EDGE_MODE, edge)) { |
| MY_LOGW("cannot update MTK_EDGE_MODE"); |
| } |
| } else { |
| MY_LOGI("cannot find MTK_EDGE_MODE from in-app"); |
| edge = MTK_EDGE_MODE_OFF; |
| } |
| if (tryGetMetadata<MUINT8>(&inAppMetadata, MTK_NOISE_REDUCTION_MODE, |
| &noise)) { |
| MY_LOGD1("MTK_NOISE_REDUCTION_MODE from in-app %d", noise); |
| if (!trySetMetadata<MUINT8>(&outAppMetadata, MTK_NOISE_REDUCTION_MODE, |
| noise)) { |
| MY_LOGW("cannot update MTK_NOISE_REDUCTION_MODE"); |
| } |
| } else { |
| MY_LOGI("cannot find MTK_NOISE_REDUCTION_MODE from in-app"); |
| noise = MTK_NOISE_REDUCTION_MODE_OFF; |
| } |
| if (tryGetMetadata<MFLOAT>( |
| &inAppMetadata, MTK_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR, &factor)) { |
| MY_LOGD1("MTK_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR from in-app %f", |
| factor); |
| if (!trySetMetadata<MFLOAT>(&outAppMetadata, |
| MTK_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR, |
| factor)) { |
| MY_LOGW("cannot update MTK_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR"); |
| } |
| } else { |
| MY_LOGI( |
| "cannot find MTK_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR from in-app"); |
| factor = (1.0f); |
| } |
| } |
| // APP out Meta Stream |
| if (!trySetMetadata<MINT64>( // always set sensor-timestamp |
| &outAppMetadata, MTK_SENSOR_TIMESTAMP, timestamp)) { |
| MY_LOGW("cannot update MTK_SENSOR_TIMESTAMP"); |
| } |
| // |
| if (OK != act->frameMetadataGet(STREAM_META_OUT_APP, NULL, MTRUE, |
| &outAppMetadata)) { |
| MY_LOGW("cannot write out-app-metadata"); |
| } |
| // HAL in/out Meta Stream |
| if (OK != act->frameMetadataGet(STREAM_META_IN_HAL, &inHalMetadata)) { |
| MY_LOGW("cannot get in-hal-metadata"); |
| } else { |
| outHalMetadata = inHalMetadata; |
| if (!trySetMetadata<MINT32>(&outHalMetadata, MTK_P1NODE_SENSOR_MODE, |
| mSensorParams.mode)) { |
| MY_LOGW("cannot update MTK_P1NODE_SENSOR_MODE"); |
| } |
| if (!trySetMetadata<MINT32>(&outHalMetadata, MTK_P1NODE_SENSOR_VHDR_MODE, |
| mSensorParams.vhdrMode)) { |
| MY_LOGW("cannot update MTK_P1NODE_SENSOR_MODE"); |
| } |
| if (!trySetMetadata<MRect>( |
| &outHalMetadata, MTK_P1NODE_SCALAR_CROP_REGION, |
| MRect(mSensorParams.size.w, mSensorParams.size.h))) { |
| MY_LOGW("cannot update MTK_P1NODE_SCALAR_CROP_REGION"); |
| } |
| if (!trySetMetadata<MRect>( |
| &outHalMetadata, MTK_P1NODE_DMA_CROP_REGION, |
| MRect(mSensorParams.size.w, mSensorParams.size.h))) { |
| MY_LOGW("cannot update MTK_P1NODE_DMA_CROP_REGION"); |
| } |
| if (!trySetMetadata<MSize>(&outHalMetadata, MTK_P1NODE_RESIZER_SIZE, |
| mSensorParams.size)) { |
| MY_LOGW("cannot update MTK_P1NODE_RESIZER_SIZE"); |
| } |
| if (OK != act->frameMetadataGet(STREAM_META_OUT_HAL, NULL, MTRUE, |
| &outHalMetadata)) { |
| MY_LOGW("cannot write out-hal-metadata"); |
| } |
| } |
| // |
| FUNCTION_OUT; |
| // |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::releaseAction(P1QueAct* rAct) { |
| FUNCTION_IN; |
| // |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| // |
| P1_TRACE_F_BEGIN(SLG_I, |
| "P1:release|Mnum:%d SofIdx:%d Fnum:%d Rnum:%d " |
| "FlushSet:0x%x", |
| act->magicNum, act->sofIdx, act->frmNum, act->reqNum, |
| act->flushSet); |
| // |
| MY_LOGD(P1INFO_ACT_STR " begin", P1INFO_ACT_VAR(*act)); |
| // |
| if (!act->getFlush()) { |
| if (act->reqType == REQ_TYPE_REDO) { |
| processRedoFrame(rAct); |
| } else if (act->reqType == REQ_TYPE_YUV) { |
| processYuvFrame(rAct); |
| } |
| } |
| // |
| for (int stream = STREAM_ITEM_START; stream < STREAM_META_NUM; stream++) { |
| if (act->streamBufMeta[stream].bExist) { |
| if (OK != act->frameMetadataPut((STREAM_META)stream)) { |
| MY_LOGD("cannot put metadata stream(%d)", stream); |
| } |
| } |
| } |
| // |
| for (int stream = STREAM_ITEM_START; stream < STREAM_IMG_NUM; stream++) { |
| if ((!act->streamBufImg[stream].bExist) && // for INITIAL act |
| (act->streamBufImg[stream].eSrcType == IMG_BUF_SRC_NULL)) { |
| continue; // this stream is not existent and no pool/stuff buffer |
| } |
| switch (act->streamBufImg[stream].eSrcType) { |
| case IMG_BUF_SRC_STUFF: |
| if (OK != act->stuffImagePut((STREAM_IMG)stream)) { |
| MY_LOGD("cannot put stuff image stream(%d)", stream); |
| } |
| break; |
| case IMG_BUF_SRC_POOL: |
| if (OK != act->poolImagePut((STREAM_IMG)stream)) { |
| MY_LOGD("cannot put pool image stream(%d)", stream); |
| } |
| break; |
| case IMG_BUF_SRC_FRAME: |
| case IMG_BUF_SRC_NULL: // for flush act, buf src is not decided |
| if (OK != act->frameImagePut((STREAM_IMG)stream)) { |
| MY_LOGD("cannot put frame image stream(%d)", stream); |
| } |
| break; |
| default: |
| MY_LOGW("act buffer source is not defined"); |
| MY_LOGW("check act exe " P1INFO_ACT_STR, P1INFO_ACT_VAR(*act)); |
| break; |
| } |
| } |
| // |
| if (act->getType() == ACT_TYPE_INTERNAL) { |
| mTagOut.set(rAct->getNum()); |
| if (1 <= mLogLevelI) { |
| P1_TRACE_F_BEGIN(SLG_PFL, |
| "P1::DEQ_LOG|Mnum:%d SofIdx:%d Fnum:%d " |
| "Rnum:%d FlushSet:0x%x", |
| act->magicNum, act->sofIdx, act->frmNum, act->reqNum, |
| act->flushSet); |
| P1_LOGI(1, "%s [InternalReturn]", act->res.c_str()); |
| P1_TRACE_C_END(SLG_PFL); // "P1::DEQ_LOG" |
| } |
| MY_LOGD(P1INFO_ACT_STR " INTERNAL return", P1INFO_ACT_VAR(*act)); |
| if (mpTaskCtrl != nullptr) { |
| mpTaskCtrl->releaseAct(rAct); |
| /* DO NOT use this P1QueAct after releaseAct() */ |
| } |
| P1_TRACE_C_END(SLG_I); // "P1:release" |
| return; |
| } |
| // |
| MY_LOGD(P1INFO_ACT_STR " applyRelease", P1INFO_ACT_VAR(*act)); |
| // |
| // Apply buffers to release |
| IStreamBufferSet& rStreamBufferSet = act->appFrame->getStreamBufferSet(); |
| // |
| if (1 <= mLogLevelI) { |
| P1_TRACE_F_BEGIN(SLG_PFL, |
| "P1::DEQ_LOG|Mnum:%d SofIdx:%d Fnum:%d " |
| "Rnum:%d FlushSet:0x%x", |
| act->magicNum, act->sofIdx, act->frmNum, act->reqNum, |
| act->flushSet); |
| std::string strInfo(""); |
| base::StringAppendF(&strInfo, "%s [ApplyRelease]", act->res.c_str()); |
| mNoteRelease.get(&strInfo); |
| P1_LOGI(1, "%s", strInfo.c_str()); |
| P1_TRACE_C_END(SLG_PFL); // "P1::DEQ_LOG" |
| } |
| // |
| P1_TRACE_S_BEGIN(SLG_I, "P1:applyRelease"); |
| rStreamBufferSet.applyRelease(getNodeId()); |
| P1_TRACE_C_END(SLG_I); // "P1:applyRelease" |
| // |
| if (1 <= mLogLevelI) { |
| mNoteRelease.set(act->frmNum); |
| } |
| // |
| MY_LOGD(P1INFO_ACT_STR " end", P1INFO_ACT_VAR(*act)); |
| |
| if (mpTaskCtrl != nullptr) { |
| mpTaskCtrl->releaseAct(rAct); |
| /* DO NOT use this P1QueAct after releaseAct() */ |
| } |
| |
| P1_TRACE_C_END(SLG_I); // "P1:release" |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::releaseFrame(P1FrameAct* rFrameAct) { |
| FUNCTION_IN; |
| // |
| if (CC_UNLIKELY(rFrameAct->appFrame == nullptr)) { |
| MY_LOGE("PipelineFrame is NULL - " P1INFO_ACT_STR, |
| P1INFO_ACT_VAR(*rFrameAct)); |
| return; |
| } |
| // |
| #if (USING_DRV_IO_PIPE_EVENT) |
| eventStreamingInform(); |
| #endif |
| // |
| LogInfo::AutoMemo _m(&mLogInfo, LogInfo::CP_OUT_BGN, LogInfo::CP_OUT_END, |
| rFrameAct->magicNum, rFrameAct->frmNum, |
| rFrameAct->reqNum); |
| // |
| int32_t currReqCnt = 0; |
| currReqCnt = std::atomic_fetch_sub_explicit(&mInFlightRequestCnt, 1, |
| std::memory_order_release); |
| P1_TRACE_INT(SLG_B, "P1_request_cnt", |
| std::atomic_load_explicit(&mInFlightRequestCnt, |
| std::memory_order_acquire)); |
| MY_LOGD("InFlightRequestCount-- (%d) => (%d)", currReqCnt, |
| std::atomic_load_explicit(&mInFlightRequestCnt, |
| std::memory_order_acquire)); |
| // |
| #if 1 |
| // camera display systrace - Dispatch |
| if (rFrameAct->reqType == REQ_TYPE_NORMAL && rFrameAct->appFrame != nullptr && |
| rFrameAct->frameTimeStamp > 0) { |
| MINT64 const timestamp = rFrameAct->frameTimeStamp; |
| P1_TRACE_F_BEGIN( |
| SLG_B, // add information |
| "Cam:%d:IspP1:dispatch|timestamp(ns):%" PRId64 " duration(ns):%" PRId64 |
| " request:%d frame:%d", |
| getOpenId(), timestamp, NSCam::Utils::getTimeInNs() - timestamp, |
| rFrameAct->appFrame->getRequestNo(), rFrameAct->appFrame->getFrameNo()); |
| P1_TRACE_C_END(SLG_B); // "IspP1:dispatch" |
| } |
| #endif |
| // |
| if (CC_LIKELY(rFrameAct->reqType == REQ_TYPE_NORMAL)) { |
| mTagOut.set(rFrameAct->magicNum); |
| } |
| if (1 <= mLogLevelI) { |
| P1_TRACE_F_BEGIN(SLG_PFL, |
| "P1::OUT_LOG|Mnum:%d SofIdx:%d Fnum:%d " |
| "Rnum:%d FlushSet:0x%x", |
| rFrameAct->magicNum, rFrameAct->sofIdx, rFrameAct->frmNum, |
| rFrameAct->reqNum, rFrameAct->flushSet); |
| std::string strInfo(""); |
| base::StringAppendF( |
| &strInfo, "[P1::OUT]" P1INFO_ACT_STR " [Release-%d] [DispatchFrame]", |
| P1INFO_ACT_VAR(*rFrameAct), |
| ((rFrameAct->flushSet == FLUSH_NONEED) ? 0 : 1)); |
| mNoteDispatch.get(&strInfo); |
| P1_LOGI(1, "%s", strInfo.c_str()); |
| P1_TRACE_C_END(SLG_PFL); // "P1::OUT_LOG" |
| } |
| // |
| P1_TRACE_F_BEGIN(SLG_I, |
| "onDispatchFrame|Mnum:%d SofIdx:%d Fnum:%d Rnum:%d " |
| "FlushSet:0x%x", |
| rFrameAct->magicNum, rFrameAct->sofIdx, rFrameAct->frmNum, |
| rFrameAct->reqNum, rFrameAct->flushSet); |
| // |
| // dispatch to next node |
| dispatch(rFrameAct->appFrame); |
| // |
| MY_LOGI("[Dispatch-Return] " P1INFO_ACT_STR " (m_%" PRId64 |
| ") " |
| "(b_%" PRId64 ")", |
| P1INFO_ACT_VAR(*rFrameAct), rFrameAct->frameTimeStamp, |
| rFrameAct->frameTimeStampBoot); |
| // |
| if (1 <= mLogLevelI) { |
| mNoteDispatch.set(rFrameAct->frmNum); |
| } |
| // |
| P1_TRACE_C_END(SLG_I); // "onDispatchFrame" |
| // |
| FUNCTION_OUT; |
| // |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::dispatch(std::shared_ptr<IPipelineFrame> pFrame) { |
| FUNCTION_IN; |
| // |
| // dispatch to next node |
| MY_LOGI("onDispatchFrame +++ FrameNum(%d) RequestNum(%d)", |
| P1GET_FRM_NUM(pFrame), P1GET_REQ_NUM(pFrame)); |
| onDispatchFrame(pFrame); |
| MY_LOGI("onDispatchFrame --- FrameNum(%d) RequestNum(%d)", |
| P1GET_FRM_NUM(pFrame), P1GET_REQ_NUM(pFrame)); |
| // |
| FUNCTION_OUT; |
| // |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::requestMetadataEarlyCallback(P1QueAct* rAct, |
| STREAM_META const streamMeta, |
| IMetadata* pMetadata) { |
| P1Act act = GET_ACT_PTR(act, *rAct, BAD_VALUE); |
| // |
| P1_CHECK_STREAM_SET(META, streamMeta); |
| P1_CHECK_MAP_STREAM(Meta, (*act), streamMeta); |
| // |
| if (pMetadata == nullptr) { |
| MY_LOGD("Result Metadata is Null"); |
| return BAD_VALUE; |
| } |
| if (pMetadata->count() == 0) { |
| MY_LOGD("Result Metadata is Empty"); |
| return OK; |
| } |
| MY_LOGD("Meta[%d]=(%d) EarlyCB " P1INFO_ACT_STR, streamMeta, |
| pMetadata->count(), P1INFO_ACT_VAR(*act)); |
| // |
| IMetadata outMetadata = *(pMetadata); |
| DurationProfile duration("EarlyCB", 5000000LL); // 5ms |
| duration.pulse_up(); |
| P1_TRACE_S_BEGIN(SLG_I, "EarlyCB"); |
| onEarlyCallback(act->appFrame, mvStreamMeta[streamMeta]->getStreamId(), |
| outMetadata); |
| P1_TRACE_C_END(SLG_I); // "EarlyCB" |
| duration.pulse_down(); |
| if (duration.isWarning()) { |
| MY_LOGI("EarlyCB Meta[%d]=(%d) " P1INFO_ACT_STR, streamMeta, |
| pMetadata->count(), P1INFO_ACT_VAR(*act)); |
| } |
| // |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::notifyCtrlSync(P1QueAct* rAct) { |
| P1Act act = GET_ACT_PTR(act, *rAct, BAD_VALUE); |
| // |
| MY_LOGI("CtrlCb_Sync[%d] sof(%d) cap(%d) exp(%" PRId64 |
| "ns) +++ " P1INFO_ACT_STR, |
| IPipelineNodeCallback::eCtrl_Sync, act->sofIdx, act->capType, |
| act->frameExpDuration, P1INFO_ACT_VAR(*act)); |
| DurationProfile duration("CtrlCb_Sync", 3000000LL); // 3ms |
| duration.pulse_up(); |
| P1_TRACE_F_BEGIN(SLG_I, "CtrlCb_Sync[%d]", IPipelineNodeCallback::eCtrl_Sync); |
| onCtrlSync(act->appFrame, act->sofIdx, act->capType, act->frameExpDuration); |
| P1_TRACE_C_END(SLG_I); // "CtrlCb_Sync" |
| duration.pulse_down(); |
| if (duration.isWarning()) { |
| MY_LOGI("CtrlCb_Sync[%d] sof(%d) cap(%d) exp(%" PRId64 |
| "ns) " P1INFO_ACT_STR, |
| IPipelineNodeCallback::eCtrl_Sync, act->sofIdx, act->capType, |
| act->frameExpDuration, P1INFO_ACT_VAR(*act)); |
| } |
| MY_LOGI("CtrlCb_Sync[%d] sof(%d) cap(%d) exp(%" PRId64 |
| "ns) --- " P1INFO_ACT_STR, |
| IPipelineNodeCallback::eCtrl_Sync, act->sofIdx, act->capType, |
| act->frameExpDuration, P1INFO_ACT_VAR(*act)); |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::notifyCtrlMeta(IPipelineNodeCallback::eCtrlType eType, |
| P1QueAct* rAct, |
| STREAM_META const streamAppMeta, |
| IMetadata* pAppMetadata, |
| STREAM_META const streamHalMeta, |
| IMetadata* pHalMetadata, |
| MBOOL* rIsChanged) { |
| *rIsChanged = MFALSE; |
| int64_t nsWarning = 3000000LL; // 3ms |
| MBOOL bChangeLog = (0 <= mLogLevelI); |
| switch (eType) { |
| case IPipelineNodeCallback::eCtrl_Resize: |
| nsWarning = 2000000LL; |
| bChangeLog = (2 <= mLogLevelI); |
| break; |
| case IPipelineNodeCallback::eCtrl_Setting: |
| case IPipelineNodeCallback::eCtrl_Readout: |
| break; |
| default: // IPipelineNodeCallback::eCtrl_Sync |
| return OK; |
| } |
| P1Act act = GET_ACT_PTR(act, *rAct, BAD_VALUE); |
| MUINT cntApp = 0; |
| MUINT cntHal = 0; |
| P1_CHECK_STREAM_SET(META, streamAppMeta); |
| P1_CHECK_STREAM_SET(META, streamHalMeta); |
| P1_CHECK_MAP_STREAM(Meta, (*act), streamAppMeta); |
| P1_CHECK_MAP_STREAM(Meta, (*act), streamHalMeta); |
| if (CC_UNLIKELY(pAppMetadata == nullptr)) { |
| MY_LOGD("AppMetadata is Null"); |
| return BAD_VALUE; |
| } else { |
| cntApp = pAppMetadata->count(); |
| } |
| if (CC_UNLIKELY(pHalMetadata == nullptr)) { |
| MY_LOGD("HalMetadata is Null"); |
| return BAD_VALUE; |
| } else { |
| cntHal = pHalMetadata->count(); |
| } |
| MY_LOGI("CtrlCb_Meta[%d] AppMeta[%d]=(%d) HalMeta[%d]=(%d) " P1INFO_ACT_STR, |
| eType, streamAppMeta, cntApp, streamHalMeta, cntHal, |
| P1INFO_ACT_VAR(*act)); |
| // |
| IMetadata& rAppMetadata = (*(pAppMetadata)); |
| IMetadata& rHalMetadata = (*(pHalMetadata)); |
| MBOOL isChanged = MFALSE; |
| DurationProfile duration("CtrlCb_Meta", nsWarning); |
| duration.pulse_up(); |
| P1_TRACE_F_BEGIN(SLG_I, "CtrlCb_Meta[%d]", eType); |
| if (eType == IPipelineNodeCallback::eCtrl_Setting) { |
| onCtrlSetting(act->appFrame, mvStreamMeta[streamAppMeta]->getStreamId(), |
| &rAppMetadata, mvStreamMeta[streamHalMeta]->getStreamId(), |
| &rHalMetadata, &isChanged); |
| } else if (eType == IPipelineNodeCallback::eCtrl_Readout) { |
| onCtrlReadout(act->appFrame, mvStreamMeta[streamAppMeta]->getStreamId(), |
| &rAppMetadata, mvStreamMeta[streamHalMeta]->getStreamId(), |
| &rHalMetadata, &isChanged); |
| } else { // eType == IPipelineNodeCallback::eCtrl_Resize |
| onCtrlResize(act->appFrame, mvStreamMeta[streamAppMeta]->getStreamId(), |
| &rAppMetadata, mvStreamMeta[streamHalMeta]->getStreamId(), |
| &rHalMetadata, &isChanged); |
| } |
| P1_TRACE_C_END(SLG_I); // "CtrlCb_Meta" |
| duration.pulse_down(); |
| if (duration.isWarning() || (isChanged && bChangeLog)) { // for log only |
| char str[32] = {0}; |
| switch (eType) { |
| case IPipelineNodeCallback::eCtrl_Setting: |
| snprintf(str, sizeof(str), "CtrlCb_Meta[%d]-Setting", eType); |
| break; |
| case IPipelineNodeCallback::eCtrl_Readout: |
| snprintf(str, sizeof(str), "CtrlCb_Meta[%d]-Readout", eType); |
| break; |
| case IPipelineNodeCallback::eCtrl_Resize: |
| snprintf(str, sizeof(str), "CtrlCb_Meta[%d]-Resize", eType); |
| break; |
| default: // IPipelineNodeCallback::eCtrl_Sync |
| return OK; |
| } |
| if (duration.isWarning()) { |
| MY_LOGI("%s sof(%d) cap(%d) exp(%" PRId64 "ns) " P1INFO_ACT_STR, str, |
| act->sofIdx, act->capType, act->frameExpDuration, |
| P1INFO_ACT_VAR(*act)); |
| } |
| |
| if (isChanged && bChangeLog) { |
| MY_LOGI( |
| "%s change AppMeta[%d]=(%d-%d) HalMeta[%d]=(%d-%d) " P1INFO_ACT_STR, |
| str, streamAppMeta, cntApp, rAppMetadata.count(), streamHalMeta, |
| cntHal, rHalMetadata.count(), P1INFO_ACT_VAR(*act)); |
| } |
| } |
| *rIsChanged = isChanged; |
| // |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::attemptCtrlSync(P1QueAct* rAct) { |
| P1Act act = GET_ACT_PTR(act, *rAct, BAD_VALUE); |
| if ((act->appFrame != nullptr) && |
| needCtrlCb(act->appFrame, IPipelineNodeCallback::eCtrl_Sync)) { |
| notifyCtrlSync(rAct); |
| } |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::attemptCtrlSetting(P1QueAct* rAct) { |
| P1Act act = GET_ACT_PTR(act, *rAct, BAD_VALUE); |
| MBOOL bIsChanged = MFALSE; |
| if ((act->appFrame != nullptr) && |
| needCtrlCb(act->appFrame, IPipelineNodeCallback::eCtrl_Setting)) { |
| notifyCtrlMeta(IPipelineNodeCallback::eCtrl_Setting, rAct, |
| STREAM_META_IN_APP, &(act->metaSet.appMeta), |
| STREAM_META_IN_HAL, &(act->metaSet.halMeta), &bIsChanged); |
| } |
| if (bIsChanged) { |
| act->metaSet.PreSetKey = P1_PRESET_KEY_NULL; |
| } |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::attemptCtrlResize(P1QueAct* rAct, MBOOL* rIsChanged) { |
| P1Act act = GET_ACT_PTR(act, *rAct, BAD_VALUE); |
| MBOOL isChanged = MFALSE; |
| if ((act->appFrame != nullptr) && |
| needCtrlCb(act->appFrame, IPipelineNodeCallback::eCtrl_Resize)) { |
| IMetadata revAppMeta; |
| IMetadata revHalMeta; |
| notifyCtrlMeta(IPipelineNodeCallback::eCtrl_Resize, rAct, |
| STREAM_META_IN_APP, &revAppMeta, STREAM_META_IN_HAL, |
| &revHalMeta, &isChanged); |
| if (isChanged) { |
| MBOOL ctrlFlush = MFALSE; |
| prepareCropInfo(rAct, &revAppMeta, &revHalMeta, |
| PREPARE_CROP_PHASE_CONTROL_RESIZE, &ctrlFlush); |
| if (ctrlFlush) { |
| act->setFlush(FLUSH_MIS_RESIZE); |
| } |
| } |
| } |
| *rIsChanged = isChanged; |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MERROR |
| P1NodeImp::attemptCtrlReadout(P1QueAct* rAct, |
| IMetadata* pAppMetadata, |
| IMetadata* pHalMetadata, |
| MBOOL* rIsChanged) { |
| P1Act act = GET_ACT_PTR(act, *rAct, BAD_VALUE); |
| MBOOL isChanged = MFALSE; |
| if ((act->appFrame != nullptr) && |
| needCtrlCb(act->appFrame, IPipelineNodeCallback::eCtrl_Readout)) { |
| notifyCtrlMeta(IPipelineNodeCallback::eCtrl_Readout, rAct, |
| STREAM_META_OUT_APP, pAppMetadata, STREAM_META_OUT_HAL, |
| pHalMetadata, &isChanged); |
| if (isChanged) { |
| MBOOL outFlush = MFALSE; |
| if (tryGetMetadata<MINT32>(pHalMetadata, MTK_P1NODE_CTRL_READOUT_FLUSH, |
| &outFlush) && |
| (outFlush)) { |
| act->setFlush(FLUSH_MIS_READOUT); |
| } |
| } |
| } |
| *rIsChanged = isChanged; |
| return OK; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::findPortBufIndex(QBufInfo const& deqBuf, P1QueJob* job) { |
| size_t job_size = (*job).size(); |
| if ((job_size == 0) || (deqBuf.mvOut.size() % job_size > 0)) { |
| MY_LOGE("Output size is not match"); |
| return MFALSE; |
| } |
| // assume the port order is the same in each de-queue set, |
| // it only check the first de-queue set and apply to each act |
| P1_OUTPUT_PORT port = P1_OUTPUT_PORT_TOTAL; |
| MUINT32 group = 0; |
| MUINT32 index = 0; |
| for (size_t i = 0; i < (deqBuf.mvOut.size()); i += job_size) { |
| index = deqBuf.mvOut[i].mPortID.index; |
| port = P1_OUTPUT_PORT_TOTAL; |
| if (index == PORT_RRZO.index) { |
| port = P1_OUTPUT_PORT_RRZO; |
| } else if (index == PORT_IMGO.index) { |
| port = P1_OUTPUT_PORT_IMGO; |
| } else if (index == PORT_EISO.index) { |
| port = P1_OUTPUT_PORT_EISO; |
| } else if (index == PORT_LCSO.index) { |
| port = P1_OUTPUT_PORT_LCSO; |
| } else if (index == PORT_RSSO.index) { |
| port = P1_OUTPUT_PORT_RSSO; |
| } else { |
| MY_LOGE("Output port is not match"); |
| return MFALSE; |
| } |
| // |
| if (port < P1_OUTPUT_PORT_TOTAL) { |
| for (size_t j = 0; j < job_size; j++) { |
| P1Act act = GET_ACT_PTR(act, (*job).edit(j), MFALSE); |
| act->portBufIndex[port] = (group * job_size) + j; |
| } |
| } |
| group++; |
| } |
| return MTRUE; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::checkBufferDumping(P1QueAct* rAct) { |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| #if (SUPPORT_BUFFER_TUNING_DUMP) |
| if (mCamDumpEn == 0) { |
| return; |
| } |
| |
| MINT32 nDumpIMGO = property_get_int32("vendor.debug.camera.dump.p1.imgo", 0); |
| if (nDumpIMGO == 0) { |
| return; |
| } |
| |
| P1_TRACE_AUTO(SLG_E, "P1:BufferDumping"); |
| MY_LOGI("[DUMP_IMGO] " P1INFO_ACT_STR, P1INFO_ACT_VAR(*act)); |
| |
| if (act->reqType != REQ_TYPE_NORMAL) { |
| MY_LOGI("[DUMP_IMGO] not-apply (%d)", act->reqType); |
| return; |
| } |
| |
| IMetadata outHalMetadata; |
| if (OK != act->frameMetadataGet(STREAM_META_OUT_HAL, &outHalMetadata)) { |
| MY_LOGW("[DUMP_IMGO] cannot get out-hal-metadata"); |
| return; |
| } |
| // |
| std::shared_ptr<IImageBuffer> imgBuf; |
| if (mvStreamImg[STREAM_IMG_OUT_FULL] == nullptr) { |
| MY_LOGW("[DUMP_IMGO] StreamImg FULL not exist"); |
| return; |
| } |
| MY_LOGI("[DUMP_IMGO] map(%d) type(%d) state(%d) [%p]", |
| act->streamBufImg[STREAM_IMG_OUT_FULL].bExist, |
| act->streamBufImg[STREAM_IMG_OUT_FULL].eSrcType, |
| act->streamBufImg[STREAM_IMG_OUT_FULL].eLockState, |
| act->streamBufImg[STREAM_IMG_OUT_FULL].spImgBuf.get()); |
| imgBuf = act->streamBufImg[STREAM_IMG_OUT_FULL].spImgBuf; |
| if (imgBuf == NULL) { |
| MY_LOGW("[DUMP_IMGO] cannot get ImageBuffer"); |
| return; |
| } |
| // |
| NSCam::TuningUtils::FILE_DUMP_NAMING_HINT hint; |
| MBOOL res = MTRUE; |
| |
| res = extract(&hint, &outHalMetadata); |
| if (!res) { |
| MY_LOGW("[DUMP_IMGO] extract with metadata fail (%d)", res); |
| return; |
| } |
| // |
| res = extract(&hint, imgBuf.get()); |
| if (!res) { |
| MY_LOGW("[DUMP_IMGO] extract with ImgBuf fail (%d)", res); |
| return; |
| } |
| // |
| res = extract_by_SensorOpenId(&hint, getOpenId()); |
| if (!res) { |
| MY_LOGW("[DUMP_IMGO] extract with OpenId fail (%d)", res); |
| return; |
| } |
| // |
| { |
| char file_name[512]; |
| ::memset(file_name, 0, sizeof(file_name)); |
| genFileName_RAW(file_name, sizeof(file_name), &hint, |
| NSCam::TuningUtils::RAW_PORT_IMGO); |
| P1_TRACE_AUTO(SLG_E, file_name); |
| MBOOL ret = imgBuf->saveToFile(file_name); |
| MY_LOGI("[DUMP_IMGO] SaveFile[%s]:(%d)", file_name, ret); |
| } |
| #endif |
| return; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::inflightMonitoring(INFLIGHT_MONITORING_TIMING timing) { |
| MINT64 currentTime = (MINT64)(NSCam::Utils::getTimeInNs()); |
| MBOOL trigger = MFALSE; |
| { |
| std::lock_guard<std::mutex> _l(mMonitorLock); |
| if (currentTime > (mMonitorTime + (P1_PERIODIC_INSPECT_INV_NS))) { |
| mMonitorTime = currentTime; |
| trigger = MTRUE; |
| } |
| } |
| if (trigger) { |
| char str[128] = {0}; |
| |
| MINT32 cnt = (MINT32)std::atomic_load_explicit(&mInFlightRequestCnt, |
| std::memory_order_acquire); |
| switch (timing) { |
| case IMT_REQ: |
| snprintf(str, sizeof(str), |
| "[%d:AfterRequestReceived]" |
| "[Burst=%d Count=%d]", |
| timing, mBurstNum, cnt); |
| break; |
| case IMT_ENQ: |
| snprintf(str, sizeof(str), |
| "[%d:AfterEnQ]" |
| "[Burst=%d Count=%d]", |
| timing, mBurstNum, cnt); |
| break; |
| case IMT_DEQ: |
| snprintf(str, sizeof(str), |
| "[%d:AfterDeQ]" |
| "[Burst=%d Count=%d]", |
| timing, mBurstNum, cnt); |
| break; |
| default: // IMT_COMMON |
| snprintf(str, sizeof(str), |
| "[%d:CommonCase]" |
| "[Burst=%d Count=%d]", |
| timing, mBurstNum, cnt); |
| break; |
| } |
| mLogInfo.inspect(LogInfo::IT_PERIODIC_CHECK, str); |
| } |
| return; |
| } |
| |
| MUINT32 |
| P1NodeImp::get_and_increase_magicnum() { |
| std::lock_guard<std::mutex> _l(mLastNumLock); |
| uint32_t magicnum = 0; |
| if (CC_UNLIKELY(mpCamIO.get() == nullptr)) { |
| MY_LOGE("cannot generate magicnum since mpCamIO is nullptr"); |
| return -1U; |
| } |
| |
| MBOOL _result = mpCamIO->sendCommand(ENPipeCmd_GEN_MAGIC_NUM, |
| reinterpret_cast<MINTPTR>(&magicnum), 0, |
| 0); // arg2, arg3 <-- dont care |
| |
| if (CC_UNLIKELY(_result != MTRUE)) { |
| MY_LOGE("mpCamIO returns fail with cmd(ENPipeCmd_GEN_MAGIC_NUM)"); |
| return -1U; |
| } |
| |
| MY_LOGD("gen magicnum=%u", magicnum); |
| |
| mLastNum = magicnum; |
| |
| MUINT32 ret = mLastNum; |
| // skip num = 0 as 3A would callback 0 when request stack is empty |
| // skip -1U as a reserved number to indicate that which would never happen in |
| // 3A queue |
| if (ret == 0 || ret == -1U) { |
| ret = mLastNum = 1; |
| } |
| return ret; |
| } |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MVOID |
| P1NodeImp::onReturnFrame(P1QueAct* rAct, |
| FLUSH_TYPE flushType, |
| MBOOL isTrigger) { |
| P1Act act = GET_ACT_PTR(act, *rAct, RET_VOID); |
| // |
| P1_TRACE_F_BEGIN(SLG_I, "P1:return|Mnum:%d SofIdx:%d Fnum:%d Rnum:%d", |
| act->magicNum, act->sofIdx, act->frmNum, act->reqNum); |
| // |
| if (flushType != FLUSH_NONEED) { |
| act->setFlush(flushType); |
| } |
| if (act->getFlush() && getActive()) { |
| MY_LOGI("need flush act " P1INFO_ACT_STR, P1INFO_ACT_VAR(*act)); |
| } |
| act->exeState = EXE_STATE_DONE; |
| // |
| if (1 <= mLogLevelI) { |
| if (CC_UNLIKELY(!act->isReadoutReady)) { |
| std::string strInfo(""); |
| strInfo += base::StringPrintf( |
| "[P1::DEL]" P1INFO_ACT_STR |
| " Readout(%d)" |
| " Bypass(%d) ", |
| P1INFO_ACT_VAR(*act), act->isReadoutReady, |
| ((act->getType() == ACT_TYPE_BYPASS) ? MTRUE : MFALSE)); |
| act->res += strInfo; |
| } |
| } |
| // |
| releaseAction(rAct); |
| // |
| if (CC_LIKELY(ACT_TYPE_INTERNAL != rAct->getType())) { |
| if (CC_LIKELY(act->appFrame != nullptr)) { |
| if (mpDeliverMgr != nullptr && mpDeliverMgr->runningGet()) { |
| mpDeliverMgr->sendActQueue(rAct, isTrigger); |
| } else { |
| P1FrameAct frameAct(rAct); |
| if (CC_LIKELY(frameAct.ready())) { |
| releaseFrame(&frameAct); |
| } else { |
| MY_LOGE("FrameAct not ready to release - " P1INFO_ACT_STR, |
| P1INFO_ACT_VAR(*act)); |
| } |
| } |
| } else { |
| MY_LOGE("PipelineFrame is nullptr - " P1INFO_ACT_STR, |
| P1INFO_ACT_VAR(*act)); |
| } |
| } |
| /* DO NOT use this P1QueAct after releaseAction() / sendActQueue() */ |
| P1_TRACE_C_END(SLG_I); // "P1:return" |
| return; |
| } |
| |
| #if 1 |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // IndependentVerification Implementation |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| MBOOL |
| P1NodeImp::IndependentVerification::exe(void) { |
| MBOOL bLoop = MTRUE; |
| std::shared_ptr<P1NodeImp> spP1NodeImp = mwpP1NodeImp.lock(); |
| if (CC_UNLIKELY(spP1NodeImp == nullptr)) { |
| MY_LOGI("[P1_IV] exit"); |
| bLoop = MFALSE; |
| return bLoop; |
| } |
| { |
| // for Periodic Inspection |
| MY_LOGI("[P1_IV] InflightMonitoring +++"); |
| spP1NodeImp->inflightMonitoring(IMT_COMMON); |
| MY_LOGI("[P1_IV] InflightMonitoring ---"); |
| } |
| // |
| return bLoop; |
| } |
| #endif |
| |
| }; // namespace NSP1Node |
| }; // namespace v3 |
| }; // namespace NSCam |
| |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| /****************************************************************************** |
| * |
| ******************************************************************************/ |
| std::shared_ptr<NSCam::v3::P1Node> NSCam::v3::P1Node::createInstance() { |
| return std::make_shared<NSCam::v3::NSP1Node::P1NodeImp>(); |
| } |
| |
| #if MTKCAM_HAVE_SANDBOX_SUPPORT |
| int NSCam::v3::NSP1Node::P1NodeImp::setDynamicSensorInfoToIPCHalSensor( |
| size_t sensorIdx) { |
| IHalSensorList* pHalSensorList = GET_HalSensorList(); |
| IIPCHalSensorListProv* pIPCSensorList = IIPCHalSensorListProv::getInstance(); |
| |
| if (CC_UNLIKELY(pHalSensorList == nullptr)) { |
| MY_LOGE("IHalSensorList is nullptr"); |
| return -1; |
| } |
| if (CC_UNLIKELY(pIPCSensorList == nullptr)) { |
| MY_LOGE("IIPCHalSensorListProv is nullptr"); |
| return -1; |
| } |
| |
| IHalSensor* pHalSensor = pHalSensorList->createSensor(LOG_TAG, sensorIdx); |
| IIPCHalSensor* pIPCSensor = static_cast<IIPCHalSensor*>( |
| pIPCSensorList->createSensor(LOG_TAG, sensorIdx)); |
| |
| if (CC_UNLIKELY(pHalSensor == nullptr)) { |
| MY_LOGE("IHalSensor is nullptr"); |
| return -1; |
| } |
| if (CC_UNLIKELY(pIPCSensor == nullptr)) { |
| MY_LOGE("IIPCHalSensor is nullptr"); |
| return -1; |
| } |
| |
| SensorDynamicInfo info; |
| MBOOL ok = pHalSensor->querySensorDynamicInfo(sensorIdx, &info); |
| if (CC_UNLIKELY(ok == MFALSE)) { |
| MY_LOGE("query SensorDynamicInfo returns failed"); |
| return -1; |
| } |
| |
| // set info to IPCHalSensor |
| pIPCSensor->ipcSetDynamicInfo(info); |
| return 0; |
| } |
| |
| int NSCam::v3::NSP1Node::P1NodeImp::setDynamicInfoExToIPCHalSensor( |
| size_t sensorIdx, const IIPCHalSensor::DynamicInfo& info) { |
| IIPCHalSensorListProv* pIPCSensorList = IIPCHalSensorListProv::getInstance(); |
| if (CC_UNLIKELY(pIPCSensorList == nullptr)) { |
| MY_LOGE("IIPCHalSensorListProv is nullptr"); |
| return -1; |
| } |
| IIPCHalSensor* pIPCSensor = static_cast<IIPCHalSensor*>( |
| pIPCSensorList->createSensor(LOG_TAG, sensorIdx)); |
| |
| if (CC_UNLIKELY(pIPCSensor == nullptr)) { |
| MY_LOGE("IIPCHalSensor is nullptr"); |
| return -1; |
| } |
| |
| pIPCSensor->ipcSetDynamicInfoEx(info); |
| return 0; |
| } |
| |
| #endif |
