| /* |
| * 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. |
| */ |
| |
| #include "camera/hal/mediatek/mtkcam/pipeline/hwnode/p2/P2_MWFrameRequest.h" |
| |
| #include <mtkcam/utils/debug/P2_DebugControl.h> |
| #define P2_CLASS_TAG MWFrameRequest |
| #define P2_TRACE TRACE_MW_FRAME_REQUEST |
| #include "P2_LogHeader.h" |
| |
| #include <memory> |
| #include <vector> |
| |
| namespace P2 { |
| |
| MWFrameRequest::MWFrameRequest(const ILog& log, |
| const P2Pack& pack, |
| const std::shared_ptr<P2DataObj>& p2Data, |
| const std::shared_ptr<MWInfo>& mwInfo, |
| const std::shared_ptr<MWFrame>& frame, |
| const std::shared_ptr<P2InIDMap>& p2IdMap) |
| : P2FrameRequest(log, pack, p2IdMap), |
| mP2Data(p2Data), |
| mMWInfo(mwInfo), |
| mMWFrame(frame), |
| mExtracted(MFALSE), |
| mImgCount(0) { |
| TRACE_S_FUNC_ENTER(mLog); |
| if (mMWFrame != nullptr) { |
| initP2FrameData(); |
| IPipelineFrame::InfoIOMapSet ioMap; |
| if (mMWFrame->getInfoIOMapSet(&ioMap)) { |
| printIOMap(ioMap); |
| if (mLog.getLogLevel() >= 1) { |
| mMWFrame->print(mLog, ioMap); |
| } |
| P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "createP2MetaMap"); |
| mMetaMap = createP2MetaMap(ioMap.mMetaInfoIOMapSet); |
| P2_CAM_TRACE_END(TRACE_ADVANCED); |
| if (mMWInfo != nullptr) { |
| // NOTE : prevent IOMapSet forget to add input |
| addP2Meta(&mMetaMap, IN_APP, IO_DIR_IN); |
| addP2Meta(&mMetaMap, IN_P1_HAL, IO_DIR_IN); |
| addP2Meta(&mMetaMap, IN_P1_APP, IO_DIR_IN); |
| addP2Meta(&mMetaMap, IN_P1_HAL_2, IO_DIR_IN); |
| addP2Meta(&mMetaMap, IN_P1_APP_2, IO_DIR_IN); |
| } |
| P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, |
| "updateP2FrameData_updateP2SensorData"); |
| updateP2FrameData(); |
| updateP2SensorData(); |
| P2_CAM_TRACE_END(TRACE_ADVANCED); |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MWFrameRequest::~MWFrameRequest() { |
| TRACE_S_FUNC_ENTER(mLog); |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MVOID MWFrameRequest::beginBatchRelease() { |
| TRACE_S_FUNC_ENTER(mLog); |
| if (mMWFrame != nullptr) { |
| mMWFrame->beginBatchRelease(); |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MVOID MWFrameRequest::endBatchRelease() { |
| TRACE_S_FUNC_ENTER(mLog); |
| if (mMWFrame != nullptr) { |
| mMWFrame->endBatchRelease(); |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MVOID MWFrameRequest::notifyNextCapture() { |
| TRACE_S_FUNC_ENTER(mLog); |
| if (mMWFrame != nullptr) { |
| mMWFrame->notifyNextCapture(); |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| std::vector<std::shared_ptr<P2Request>> MWFrameRequest::extractP2Requests() { |
| TRACE_S_FUNC_ENTER(mLog); |
| std::vector<std::shared_ptr<P2Request>> requests; |
| if (mExtracted) { |
| MY_S_LOGE(mLog, "Requests already extracted, should only extracted once"); |
| } else { |
| mExtracted = MTRUE; |
| IPipelineFrame::InfoIOMapSet ioMap; |
| if (mMWFrame->getInfoIOMapSet(&ioMap)) { |
| requests = createRequests(ioMap); |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return requests; |
| } |
| |
| MBOOL MWFrameRequest::addP2Img(P2ImgMap* imgMap, |
| const StreamId_T& sID, |
| ID_IMG id, |
| IO_DIR dir, |
| const IMG_INFO& info) { |
| TRACE_S_FUNC_ENTER(mLog); |
| MBOOL ret = MFALSE; |
| auto it = imgMap->find(sID); |
| if (it == imgMap->end()) { |
| if (id != info.id) { |
| MY_S_LOGW(mLog, |
| "Invalid img info(0x%09" PRIx64 "/%d:%s) id=(%d)/info.id=(%d)", |
| sID, id, info.name.c_str(), id, info.id); |
| } else if (!(info.dir & dir)) { |
| MY_S_LOGW(mLog, |
| "Invalid img info(0x%09" PRIx64 |
| "/%d:%s) dir=wanted(%d)/listed(%d)", |
| sID, id, info.name.c_str(), dir, info.dir); |
| } else if (info.flag & IO_FLAG_INVALID) { |
| MY_S_LOGW(mLog, |
| "Invalid img info(0x%09" PRIx64 |
| "/%d:%s) Invalid IO_INFO: flag(%d)", |
| sID, id, info.name.c_str(), info.flag); |
| } else { |
| P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "new MWImg"); |
| std::shared_ptr<P2Img> holder = std::make_shared<MWImg>( |
| mLog, mP2Pack, mMWFrame, sID, dir, mMWInfo->getImgType(sID), info, |
| mImgCount++, mNeedImageSWRW); |
| P2_CAM_TRACE_END(TRACE_ADVANCED); |
| if (holder == nullptr) { |
| MY_S_LOGW(mLog, "OOM: cannot create MWImg"); |
| } else { |
| (*imgMap)[sID] = holder; |
| ret = MTRUE; |
| } |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return ret; |
| } |
| |
| MBOOL MWFrameRequest::addP2Img(P2ImgMap* imgMap, |
| const StreamId_T& sID, |
| IO_DIR dir) { |
| TRACE_S_FUNC_ENTER(mLog); |
| MBOOL ret = MFALSE; |
| ID_IMG id = mMWInfo->toImgID(sID); |
| const IMG_INFO& info = P2Img::getImgInfo(id); |
| ret = addP2Img(imgMap, sID, id, dir, info); |
| TRACE_S_FUNC_EXIT(mLog); |
| return ret; |
| } |
| |
| MBOOL MWFrameRequest::addP2Img(P2ImgMap* imgMap, ID_IMG id, IO_DIR dir) { |
| TRACE_S_FUNC_ENTER(mLog); |
| MBOOL ret = MFALSE; |
| auto mwImgInfo = mMWInfo->findImgInfo(id); |
| if (mwImgInfo != nullptr) { |
| const IMG_INFO& info = P2Img::getImgInfo(id); |
| ret = addP2Img(imgMap, mwImgInfo->getStreamId(), id, dir, info); |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return ret; |
| } |
| |
| MWFrameRequest::P2ImgMap MWFrameRequest::createP2ImgMap( |
| IPipelineFrame::ImageInfoIOMapSet const& imgSet) { |
| TRACE_S_FUNC_ENTER(mLog); |
| P2ImgMap holders; |
| for (unsigned i = 0, n = imgSet.size(); i < n; ++i) { |
| for (auto& in : imgSet[i].vIn) { |
| addP2Img(&holders, in.first, IO_DIR_IN); |
| } |
| for (auto& out : imgSet[i].vOut) { |
| addP2Img(&holders, out.first, IO_DIR_OUT); |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return holders; |
| } |
| |
| MBOOL MWFrameRequest::addP2Meta(P2MetaMap* metaMap, |
| const StreamId_T& sID, |
| ID_META id, |
| IO_DIR dir, |
| const META_INFO& info) { |
| TRACE_S_FUNC_ENTER(mLog); |
| MBOOL ret = MFALSE; |
| auto it = metaMap->find(sID); |
| if (it == metaMap->end()) { |
| if (id != info.id) { |
| MY_LOGE("Invalid img info(0x%09" PRIx64 "/%d:%s) id=(%d)/info.id=(%d)", |
| sID, id, info.name.c_str(), id, info.id); |
| } else if (!(info.dir & dir)) { |
| MY_LOGE("Invalid meta info(0x%09" PRIx64 |
| "/%d:%s) dir=wanted(%d)/listed(%d)", |
| sID, id, info.name.c_str(), dir, info.dir); |
| } else if (info.flag & IO_FLAG_INVALID) { |
| MY_LOGE("Invalid meta info(0x%09" PRIx64 |
| "/%d:%s) Invalid IO_INFO: flag(%d)", |
| sID, id, info.name.c_str(), info.flag); |
| } else { |
| P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "new MWMeta"); |
| std::shared_ptr<P2Meta> holder = |
| std::make_shared<MWMeta>(mLog, mP2Pack, mMWFrame, sID, dir, info); |
| P2_CAM_TRACE_END(TRACE_ADVANCED); |
| if (holder == nullptr) { |
| MY_LOGE("OOM: cannot create MWMeta"); |
| } else { |
| (*metaMap)[sID] = holder; |
| ret = MTRUE; |
| } |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return ret; |
| } |
| |
| MBOOL MWFrameRequest::addP2Meta(P2MetaMap* metaMap, |
| const StreamId_T& sID, |
| IO_DIR dir) { |
| TRACE_S_FUNC_ENTER(mLog); |
| MBOOL ret = MFALSE; |
| ID_META id = mMWInfo->toMetaID(sID); |
| const META_INFO& info = P2Meta::getMetaInfo(id); |
| ret = addP2Meta(metaMap, sID, id, dir, info); |
| TRACE_S_FUNC_EXIT(mLog); |
| return ret; |
| } |
| |
| MBOOL MWFrameRequest::addP2Meta(P2MetaMap* metaMap, ID_META id, IO_DIR dir) { |
| TRACE_S_FUNC_ENTER(mLog); |
| MBOOL ret = MFALSE; |
| auto mwMetaInfo = mMWInfo->findMetaInfo(id); |
| if (mwMetaInfo != nullptr) { |
| const META_INFO& info = P2Meta::getMetaInfo(id); |
| ret = addP2Meta(metaMap, mwMetaInfo->getStreamId(), id, dir, info); |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return ret; |
| } |
| |
| MBOOL MWFrameRequest::removeP2Meta(P2MetaMap* metaMap, ID_META id) { |
| TRACE_S_FUNC_ENTER(mLog); |
| MBOOL ret = MFALSE; |
| auto mwMetaInfo = mMWInfo->findMetaInfo(id); |
| if (mwMetaInfo != nullptr) { |
| StreamId_T sID = mwMetaInfo->getStreamId(); |
| auto it = metaMap->find(sID); |
| if (it != metaMap->end()) { |
| metaMap->erase(it); |
| ret = MTRUE; |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return ret; |
| } |
| |
| MWFrameRequest::P2MetaMap MWFrameRequest::createP2MetaMap( |
| IPipelineFrame::MetaInfoIOMapSet const& metaSet) { |
| TRACE_S_FUNC_ENTER(mLog); |
| P2MetaMap holders; |
| for (unsigned i = 0, n = metaSet.size(); i < n; ++i) { |
| for (auto& in : metaSet[i].vIn) { |
| addP2Meta(&holders, in.first, IO_DIR_IN); |
| } |
| for (auto& out : metaSet[i].vOut) { |
| addP2Meta(&holders, out.first, IO_DIR_OUT); |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return holders; |
| } |
| |
| MVOID MWFrameRequest::configBufferSize( |
| MUINT32 sensorID, const std::shared_ptr<Cropper>& cropper) { |
| TRACE_S_FUNC_ENTER(mLog); |
| std::shared_ptr<P2Img> rrzo = findP2Img(mImgMap, mapID(sensorID, IN_RESIZED)); |
| std::shared_ptr<P2Img> rsso = findP2Img(mImgMap, mapID(sensorID, IN_RSSO)); |
| if (isValid(rrzo)) { |
| IImageBuffer* buffer = rrzo->getIImageBufferPtr(); |
| MSize size = cropper->getP1OutSize(); |
| if (size.w > 0 && size.h > 0) { |
| TRACE_S_FUNC(mLog, "resize rrzo(%p) from %dx%d to %dx%d", buffer, |
| buffer->getImgSize().w, buffer->getImgSize().h, size.w, |
| size.h); |
| buffer->setExtParam(size); |
| } |
| } |
| if (isValid(rsso)) { |
| MSize size(288, 162); // default rsso buffer size |
| if (!tryGet<MSize>(findP2Meta(IN_P1_HAL), MTK_P1NODE_RSS_SIZE, &size)) { |
| MY_S_LOGE(mLog, "cannot get MTK_P1NODE_RSS_ZIE"); |
| } |
| IImageBuffer* buffer = rsso->getIImageBufferPtr(); |
| if (size.w > 0 && size.h > 0) { |
| TRACE_S_FUNC(mLog, "resize rsso(%p) from %dx%d to %dx%d", buffer, |
| buffer->getImgSize().w, buffer->getImgSize().h, size.w, |
| size.h); |
| buffer->setExtParam(size); |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| std::shared_ptr<P2Meta> MWFrameRequest::findP2Meta(const P2MetaMap& map, |
| ID_META id) const { |
| TRACE_S_FUNC_ENTER(mLog); |
| std::shared_ptr<P2Meta> meta; |
| auto info = mMWInfo->findMetaInfo(id); |
| if (info != nullptr) { |
| auto it = map.find(info->getStreamId()); |
| if (it != map.end() && it->second != nullptr) { |
| meta = it->second; |
| } |
| } |
| TRACE_S_FUNC(mLog, "info = %p meta = %p", info.get(), meta.get()); |
| TRACE_S_FUNC_EXIT(mLog); |
| return meta; |
| } |
| |
| std::shared_ptr<P2Meta> MWFrameRequest::findP2Meta(ID_META id) const { |
| return findP2Meta(mMetaMap, id); |
| } |
| |
| std::shared_ptr<P2Img> MWFrameRequest::findP2Img(const P2ImgMap& map, |
| ID_IMG id) const { |
| TRACE_S_FUNC_ENTER(mLog); |
| std::shared_ptr<P2Img> img; |
| auto info = mMWInfo->findImgInfo(id); |
| if (info != nullptr) { |
| auto it = map.find(info->getStreamId()); |
| if (it != map.end() && it->second != nullptr) { |
| img = it->second; |
| } |
| } |
| TRACE_S_FUNC(mLog, "info = %p img = %p", info.get(), img.get()); |
| TRACE_S_FUNC_EXIT(mLog); |
| return img; |
| } |
| |
| std::shared_ptr<P2Img> MWFrameRequest::findP2Img(ID_IMG id) const { |
| return findP2Img(mImgMap, id); |
| } |
| |
| MVOID MWFrameRequest::initP2FrameData() { |
| TRACE_S_FUNC_ENTER(mLog); |
| mP2Data->mFrameData.mMWFrameNo = mMWFrame->getMWFrameID(); |
| mP2Data->mFrameData.mMWFrameRequestNo = mMWFrame->getMWFrameRequestID(); |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MVOID MWFrameRequest::updateP2FrameData() { |
| TRACE_S_FUNC_ENTER(mLog); |
| P2FrameData& data = mP2Data->mFrameData; |
| // P1 HAL |
| std::shared_ptr<P2Meta> inHalMeta = findP2Meta(mMetaMap, IN_P1_HAL); |
| MINT32 appMode = getMeta<MINT32>(inHalMeta, MTK_FEATUREPIPE_APP_MODE, |
| MTK_FEATUREPIPE_PHOTO_PREVIEW); |
| data.mAppMode = appMode; |
| data.mIsRecording = (appMode == MTK_FEATUREPIPE_VIDEO_RECORD) || |
| (appMode == MTK_FEATUREPIPE_VIDEO_STOP); |
| |
| // TODO(mtk): get Master ID from hal metadata |
| data.mMasterSensorID = mP2Pack.getConfigInfo().mMainSensorID; |
| |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MVOID MWFrameRequest::updateP2SensorData() { |
| TRACE_S_FUNC_ENTER(mLog); |
| |
| for (MUINT32 sensorID : mP2Pack.getConfigInfo().mAllSensorID) { |
| P2SensorData& data = mP2Data->mSensorDataMap[sensorID]; |
| std::shared_ptr<P2Meta> inApp = |
| findP2Meta(mMetaMap, mapID(sensorID, IN_APP)); |
| std::shared_ptr<P2Meta> p1Hal = |
| findP2Meta(mMetaMap, mapID(sensorID, IN_P1_HAL)); |
| std::shared_ptr<P2Meta> p1App = |
| findP2Meta(mMetaMap, mapID(sensorID, IN_P1_APP)); |
| const P2SensorInfo& sensorInfo = mP2Pack.getSensorInfo(sensorID); |
| |
| // P1 HAL |
| data.mSensorID = sensorID; |
| data.mMWUniqueKey = getMeta<MINT32>(p1Hal, MTK_PIPELINE_UNIQUE_KEY, 0); |
| data.mMagic3A = getMeta<MINT32>(p1Hal, MTK_P1NODE_PROCESSOR_MAGICNUM, 0); |
| data.mIspProfile = getMeta<MUINT8>(p1Hal, MTK_3A_ISP_PROFILE, 0); |
| extract(&data.mNDDHint, toIMetadataPtr(p1Hal)); |
| extract_by_SensorOpenId(&data.mNDDHint, sensorID); |
| |
| // P1 APP |
| data.mP1TS = getMeta<MINT64>(p1App, MTK_SENSOR_TIMESTAMP, 0); |
| if (!tryGet<MINT32>(p1App, MTK_SENSOR_SENSITIVITY, &(data.mISO))) { |
| tryGet<MINT32>(inApp, MTK_SENSOR_SENSITIVITY, &(data.mISO)); |
| } |
| |
| // Cropper |
| data.mSensorMode = getMeta<MINT32>(p1Hal, MTK_P1NODE_SENSOR_MODE, 0); |
| data.mSensorSize = |
| getMeta<MSize>(p1Hal, MTK_HAL_REQUEST_SENSOR_SIZE, MSize()); |
| if (!tryGet<MRect>(p1Hal, MTK_P1NODE_SCALAR_CROP_REGION, &(data.mP1Crop)) || |
| !tryGet<MRect>(p1Hal, MTK_P1NODE_DMA_CROP_REGION, &(data.mP1DMA)) || |
| !tryGet<MSize>(p1Hal, MTK_P1NODE_RESIZER_SIZE, &(data.mP1OutSize))) { |
| data.mP1Crop = MRect(MPoint(0, 0), data.mSensorSize); |
| data.mP1DMA = MRect(MPoint(0, 0), data.mSensorSize); |
| data.mP1OutSize = data.mSensorSize; |
| } |
| |
| if (!tryGet<MRect>(p1Hal, MTK_P1NODE_BIN_CROP_REGION, &(data.mP1BinCrop)) || |
| !tryGet<MSize>(p1Hal, MTK_P1NODE_BIN_SIZE, &(data.mP1BinSize))) { |
| data.mP1BinCrop = MRect(MPoint(0, 0), data.mSensorSize); |
| data.mP1BinSize = data.mSensorSize; |
| } |
| |
| if (MTK_CONTROL_VIDEO_STABILIZATION_MODE_ON == |
| getMeta<MUINT8>(inApp, MTK_CONTROL_VIDEO_STABILIZATION_MODE, |
| MTK_CONTROL_VIDEO_STABILIZATION_MODE_OFF) || |
| MTK_EIS_FEATURE_EIS_MODE_ON == |
| getMeta<MINT32>(inApp, MTK_EIS_FEATURE_EIS_MODE, |
| MTK_EIS_FEATURE_EIS_MODE_OFF)) { |
| data.mAppEISOn = MTRUE; |
| } |
| data.mAppCrop = |
| getMeta<MRect>(inApp, MTK_SCALER_CROP_REGION, |
| MRect(MPoint(0, 0), sensorInfo.mActiveArray.s)); |
| MY_LOGD("extractLMVInfo +"); |
| LMVInfo lmvInfo = extractLMVInfo(mLog, toIMetadataPtr(p1Hal)); |
| data.mCropper = |
| std::make_shared<P2Cropper>(mLog, &sensorInfo, &data, lmvInfo); |
| MY_LOGD("extractLMVInfo new P2Cropper - "); |
| } |
| |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MVOID MWFrameRequest::updateP2Metadata( |
| MUINT32 sensorID, const std::shared_ptr<Cropper>& cropper) { |
| TRACE_S_FUNC_ENTER(mLog); |
| std::shared_ptr<P2Meta> inHalMeta; |
| inHalMeta = findP2Meta(mMetaMap, mapID(sensorID, IN_P1_HAL)); |
| if (inHalMeta == nullptr) { |
| return; |
| } |
| |
| MRect rect; |
| if (!inHalMeta->tryGet<MRect>(MTK_3A_PRV_CROP_REGION, &rect)) { |
| std::shared_ptr<P2Img> display; |
| for (auto& it : mImgMap) { |
| if (it.second->isDisplay()) { |
| display = it.second; |
| break; |
| } |
| } |
| if (isValid(display)) { |
| std::shared_ptr<P2Img> rrzo = |
| findP2Img(mImgMap, mapID(sensorID, IN_RESIZED)); |
| MBOOL resized = isValid(rrzo); |
| |
| MUINT32 cropFlag = 0; |
| cropFlag |= resized ? Cropper::USE_RESIZED : 0; |
| |
| MCropRect crop = |
| cropper->calcViewAngle(mLog, display->getTransformSize(), cropFlag); |
| rect = cropper->toActive(crop, resized); |
| P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "inHalMeta->trySet<MRect>"); |
| inHalMeta->trySet<MRect>(MTK_3A_PRV_CROP_REGION, rect); |
| P2_CAM_TRACE_END(TRACE_ADVANCED); |
| } |
| } |
| TRACE_S_FUNC_ENTER(mLog); |
| } |
| |
| MBOOL MWFrameRequest::fillP2Img(const std::shared_ptr<P2Request>& request, |
| const std::shared_ptr<P2Img>& img) { |
| TRACE_S_FUNC_ENTER(mLog); |
| MBOOL ret = MFALSE; |
| if (request != nullptr && img != nullptr) { |
| ID_IMG id = img->getID(); |
| if (id == OUT_YUV) { |
| request->mImgOutArray.push_back(img); |
| } else { |
| request->mImg[id] = img; |
| } |
| ret = MTRUE; |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return ret; |
| } |
| |
| MBOOL MWFrameRequest::fillP2Meta(const std::shared_ptr<P2Request>& request, |
| const std::shared_ptr<P2Meta>& meta) { |
| TRACE_S_FUNC_ENTER(mLog); |
| MBOOL ret = MFALSE; |
| if (request != nullptr && meta != nullptr) { |
| ID_META id = meta->getID(); |
| request->mMeta[id] = meta; |
| ret = MTRUE; |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| return ret; |
| } |
| |
| MVOID MWFrameRequest::fillP2Img( |
| const std::shared_ptr<P2Request>& request, |
| const IPipelineFrame::ImageInfoIOMap& imgInfoMap, |
| const P2ImgMap& p2ImgMap) { |
| TRACE_S_FUNC_ENTER(mLog); |
| for (auto& i : imgInfoMap.vIn) { |
| auto it = p2ImgMap.find(i.first); |
| if (it != p2ImgMap.end()) { |
| fillP2Img(request, it->second); |
| } |
| } |
| for (auto& i : imgInfoMap.vOut) { |
| auto it = p2ImgMap.find(i.first); |
| if (it != p2ImgMap.end()) { |
| fillP2Img(request, it->second); |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MVOID MWFrameRequest::fillP2Meta( |
| const std::shared_ptr<P2Request>& request, |
| const IPipelineFrame::MetaInfoIOMap& metaInfoMap, |
| const P2MetaMap& p2MetaMap) { |
| TRACE_S_FUNC_ENTER(mLog); |
| for (auto& i : metaInfoMap.vIn) { |
| auto it = p2MetaMap.find(i.first); |
| if (it != p2MetaMap.end()) { |
| fillP2Meta(request, it->second); |
| } |
| } |
| for (auto& i : metaInfoMap.vOut) { |
| auto it = p2MetaMap.find(i.first); |
| if (it != p2MetaMap.end()) { |
| fillP2Meta(request, it->second); |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MVOID MWFrameRequest::fillDefaultP2Meta( |
| const std::shared_ptr<P2Request>& request, |
| const P2MetaMap& metaMap, |
| MUINT32 sensorID) { |
| TRACE_S_FUNC_ENTER(mLog); |
| fillP2Meta(request, findP2Meta(metaMap, mapID(sensorID, IN_APP))); |
| fillP2Meta(request, findP2Meta(metaMap, mapID(sensorID, IN_P1_HAL))); |
| fillP2Meta(request, findP2Meta(metaMap, mapID(sensorID, IN_P1_APP))); |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| MVOID MWFrameRequest::printIOMap(const IPipelineFrame::InfoIOMapSet& ioMap) { |
| TRACE_S_FUNC_ENTER(mLog); |
| const IPipelineFrame::ImageInfoIOMapSet& imgSet = ioMap.mImageInfoIOMapSet; |
| const IPipelineFrame::MetaInfoIOMapSet& metaSet = ioMap.mMetaInfoIOMapSet; |
| char buffer[256]; |
| unsigned used = 0; |
| |
| used = snprintf(buffer, sizeof(buffer), "iomap:"); |
| |
| unsigned imgSize = imgSet.size(); |
| unsigned metaSize = metaSet.size(); |
| unsigned maxSize = (imgSize >= metaSize) ? imgSize : metaSize; |
| for (unsigned i = 0; i < maxSize; ++i) { |
| unsigned imgIn = 0, imgOut = 0, metaIn = 0, metaOut = 0; |
| if (i < imgSize) { |
| imgIn = imgSet[i].vIn.size(); |
| imgOut = imgSet[i].vOut.size(); |
| } |
| if (i < metaSize) { |
| metaIn = metaSet[i].vIn.size(); |
| metaOut = metaSet[i].vOut.size(); |
| } |
| if (used < sizeof(buffer)) { |
| used += snprintf(buffer + used, sizeof(buffer) - used, |
| " [%d]=>img[%d/%d], meta[%d/%d]", i, imgIn, imgOut, |
| metaIn, metaOut); |
| } |
| } |
| MY_S_LOGD(mLog, "%s", buffer); |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| std::vector<std::shared_ptr<P2Request>> MWFrameRequest::createRequests( |
| IPipelineFrame::InfoIOMapSet const& ioMap) { |
| TRACE_S_FUNC_ENTER(mLog); |
| std::vector<std::shared_ptr<P2Request>> requests; |
| IPipelineFrame::ImageInfoIOMapSet const& imgSet = ioMap.mImageInfoIOMapSet; |
| IPipelineFrame::MetaInfoIOMapSet const& metaSet = ioMap.mMetaInfoIOMapSet; |
| |
| if (imgSet.size() == 0 || metaSet.size() == 0 || |
| imgSet.size() != metaSet.size()) { |
| MY_S_LOGW(mLog, "iomap image=%zu meta=%zu", imgSet.size(), metaSet.size()); |
| } |
| P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, |
| "MWFrameRequest::createRequests->createP2ImgMap"); |
| mImgMap = createP2ImgMap(imgSet); |
| P2_CAM_TRACE_END(TRACE_ADVANCED); |
| |
| for (MUINT32 sensorID : mP2Pack.getConfigInfo().mAllSensorID) { |
| std::shared_ptr<Cropper> cropper = mP2Pack.getSensorData(sensorID).mCropper; |
| configBufferSize(sensorID, cropper); |
| updateP2Metadata(sensorID, cropper); |
| } |
| |
| TRACE_S_FUNC(mLog, "imgMap=%zu metaMap=%zu", mImgMap.size(), mMetaMap.size()); |
| |
| P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, |
| "MWFrameRequest::createRequests->doRegisterPlugin"); |
| doRegisterPlugin(); |
| P2_CAM_TRACE_END(TRACE_ADVANCED); |
| |
| P2_CAM_TRACE_BEGIN( |
| TRACE_ADVANCED, |
| "MWFrameRequest::createRequests->newP2Request_fillImg_Meta"); |
| for (unsigned i = 0, n = imgSet.size(); i < n; ++i) { |
| ILog reqLog = makeRequestLogger(mLog, i); |
| std::shared_ptr<P2Request> request = |
| std::make_shared<P2Request>(reqLog, mMWFrame, mP2Pack, mInIDMap); |
| if (request == nullptr) { |
| MY_S_LOGW(reqLog, "OOM: cannot allocate P2Request (%d/%d)", i, n); |
| continue; |
| } |
| |
| fillP2Img(request, imgSet[i], mImgMap); |
| if (i < metaSet.size()) { |
| fillP2Meta(request, metaSet[i], mMetaMap); |
| } |
| |
| for (MUINT32 sensorID : mP2Pack.getConfigInfo().mAllSensorID) { |
| fillDefaultP2Meta(request, mMetaMap, sensorID); |
| } |
| |
| request->initIOInfo(); |
| requests.push_back(request); |
| } |
| P2_CAM_TRACE_END(TRACE_ADVANCED); |
| |
| this->beginBatchRelease(); |
| mImgMap.clear(); |
| mMetaMap.clear(); |
| this->endBatchRelease(); |
| |
| TRACE_S_FUNC_EXIT(mLog); |
| return requests; |
| } |
| |
| MVOID MWFrameRequest::doRegisterPlugin() { |
| TRACE_S_FUNC_ENTER(mLog); |
| for (auto it : mImgMap) { |
| if (it.second != nullptr) { |
| it.second->registerPlugin(mImgPlugin); |
| } |
| } |
| TRACE_S_FUNC_EXIT(mLog); |
| } |
| |
| } // namespace P2 |
