camera/hal/mediatek/mtkcam/pipeline/hwnode/p2/P2_BasicProcessor.cpp - mirrors/cros/chromiumos/platform2 - Git at Google

 /*
  * 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_BasicProcessor.h"
 #include "P2_Util.h"
 #include <src/pass2/NormalStream.h>

 #include <memory>
 #include <vector>

 #define LOG_TAG "P2_BasicProcessor"

 #define P2_BASIC_THREAD_NAME "p2_basic"
 #define FORCE_BURST 0

 namespace P2 {

 #include <mtkcam/utils/debug/P2_DebugControl.h>
 #define P2_CLASS_TAG BasicProcessor
 #define P2_TRACE TRACE_BASIC_PROCESSOR
 #include "P2_LogHeader.h"

 BasicProcessor::BasicProcessor() : Processor(P2_BASIC_THREAD_NAME) {
   MY_LOG_FUNC_ENTER();
   MY_LOG_FUNC_EXIT();
 }

 BasicProcessor::~BasicProcessor() {
   MY_LOG_S_FUNC_ENTER(mLog);
   this->uninit();
   MY_LOG_S_FUNC_EXIT(mLog);
 }

 MBOOL BasicProcessor::onInit(const P2InitParam& param) {
   ILog log = param.mP2Info.mLog;
   MY_LOG_S_FUNC_ENTER(log);
   P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:init()");

   MBOOL ret = MFALSE;

   mP2Info = param.mP2Info;
   mLog = mP2Info.mLog;
   ret = initNormalStream() && init3A();
   if (!ret) {
     MY_S_LOGE(mLog, "P2_Basic:init fail");
     uninitNormalStream();
     uninit3A();
   }

   MY_LOG_S_FUNC_EXIT(log);
   return ret;
 }

 MVOID BasicProcessor::onUninit() {
   MY_LOG_S_FUNC_ENTER(mLog);
   P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:uninit()");
   uninitNormalStream();
   uninit3A();
   MY_LOG_S_FUNC_EXIT(mLog);
 }

 MVOID BasicProcessor::onThreadStart() {
   MY_LOG_S_FUNC_ENTER(mLog);
   P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:threadStart()");
   MY_LOG_S_FUNC_EXIT(mLog);
 }

 MVOID BasicProcessor::onThreadStop() {
   MY_LOG_S_FUNC_ENTER(mLog);
   P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:threadStop()");
   MY_LOG_S_FUNC_EXIT(mLog);
 }

 MBOOL BasicProcessor::onConfig(const P2ConfigParam& param) {
   MY_LOG_S_FUNC_ENTER(mLog);
   P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:config()");
   mP2Info = param.mP2Info;
   MY_LOG_S_FUNC_EXIT(mLog);
   return MTRUE;
 }

 MBOOL BasicProcessor::onEnque(const std::shared_ptr<P2Request>& request) {
   ILog log = spToILog(request);
   TRACE_S_FUNC_ENTER(log);
   P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:enque()");
   MBOOL ret = MFALSE;

   processVenc(request);

   if (request != nullptr && request->hasInput() && request->hasOutput()) {
     std::shared_ptr<P2Payload> payload = std::make_shared<P2Payload>(request);
     MUINT32 portFlag = mEnableVencStream ? P2Util::USE_VENC : 0;
     payload->mIO = P2Util::extractSimpleIO(request, portFlag);
     payload->mIO.setUseLMV(MFALSE);

     if (payload->mIO.hasInput() && payload->mIO.hasOutput()) {
       P2MetaSet metaSet = request->getMetaSet();
       /*add for tuning flow*/
       int size = mTuningBuffers.size();
       payload->mIO.mTuningBuffer = mTuningBuffers[size - 1];
       payload->mTuning =
           P2Util::xmakeTuning(request->mP2Pack, payload->mIO, mHal3A, &metaSet);
       request->updateMetaSet(metaSet);
       payload->mQParams =
           P2Util::xmakeQParams(request->mP2Pack, payload->mIO, payload->mTuning,
                                payload->mP2Obj.toPtrTable());
       mTuningBuffers.pop_back();

       payload->mRequest->releaseResource(P2Request::RES_IN_IMG);
       ret = processBurst(payload) || processP2(payload);
     } else {
       checkBurst();
     }
   }

   TRACE_S_FUNC_EXIT(log);
   return ret;
 }

 MVOID BasicProcessor::onNotifyFlush() {
   MY_LOG_S_FUNC_ENTER(mLog);
   P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:notifyFlush()");
   if (mBurstQueue.size()) {
     updateResult(mBurstQueue, MFALSE);
     mBurstQueue.clear();
   }
   MY_LOG_S_FUNC_EXIT(mLog);
 }

 MVOID BasicProcessor::onWaitFlush() {
   MY_LOG_S_FUNC_ENTER(mLog);
   P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:waitFlush()");
   waitP2CBDone();
   MY_LOG_S_FUNC_EXIT(mLog);
 }

 MBOOL BasicProcessor::initNormalStream() {
   TRACE_S_FUNC_ENTER(mLog);
   MBOOL ret = MFALSE;

   P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "P2_Basic:NormalStream create");
   mNormalStream = std::make_shared<NSCam::v4l2::NormalStream>(
       mP2Info.getConfigInfo().mMainSensorID);
   P2_CAM_TRACE_END(TRACE_ADVANCED);
   if (mNormalStream == nullptr) {
     MY_S_LOGE(mLog, "OOM: cannot create NormalStream");
   } else {
     P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "P2_Basic:NormalStream init");
     ret = mNormalStream->init(getName());
     P2_CAM_TRACE_END(TRACE_ADVANCED);
     if (!ret) {
       MY_S_LOGE(mLog, "NormalStream init failed");
       return MFALSE;
     }
     ret = mNormalStream->requestBuffers(
         NSImageio::NSIspio::EPortIndex_TUNING,
         NSCam::IImageBufferAllocator::ImgParam(0, 0), &mTuningBuffers);
     if (!ret) {
       MY_S_LOGE(mLog, "NormalStream requestBuffers failed");
     }
   }
   TRACE_S_FUNC_EXIT(mLog);
   return ret;
 }

 MVOID BasicProcessor::uninitNormalStream() {
   TRACE_S_FUNC_ENTER(mLog);
   if (mNormalStream) {
     configVencStream(MFALSE);
     for (auto& it : mTuningBuffers) {
       it->unlockBuf("V4L2");
     }
     mNormalStream->uninit(getName());
   }
   TRACE_S_FUNC_EXIT(mLog);
 }

 MBOOL BasicProcessor::init3A() {
   TRACE_S_FUNC_ENTER(mLog);
   MBOOL ret = MTRUE;
   P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "P2_Basic:3A create");
   MAKE_Hal3A(
       mHal3A, [](IHal3A* p) { p->destroyInstance(LOG_TAG); },
       mP2Info.getConfigInfo().mMainSensorID, LOG_TAG);

   P2_CAM_TRACE_END(TRACE_ADVANCED);
   if (mHal3A == nullptr) {
     MY_S_LOGE(mLog, "OOM: cannot create Hal3A");
     ret = MFALSE;
   }
   TRACE_S_FUNC_EXIT(mLog);
   return ret;
 }

 MVOID BasicProcessor::uninit3A() {
   TRACE_S_FUNC_ENTER(mLog);
   TRACE_S_FUNC_EXIT(mLog);
 }

 MVOID BasicProcessor::onP2CB(const QParams& qparams,
                              std::shared_ptr<P2Payload> const& payload) {
   TRACE_S_FUNC_ENTER(payload->mRequest->mLog);
   P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:onP2CB()");
   std::shared_ptr<IImageBuffer> tuningBuffer = payload->mIO.mTuningBuffer;
   mTuningBuffers.push_back(tuningBuffer);
   payload->mIO.updateResult(qparams.mDequeSuccess);
 }

 MBOOL BasicProcessor::processVenc(const std::shared_ptr<P2Request>& request) {
   TRACE_S_FUNC_ENTER(request->mLog);
   MBOOL ret = MTRUE;
   if (request != nullptr) {
     MINT32 fps = 0;
     MSize size;
     std::shared_ptr<P2Meta> meta = request->getMeta(IN_P1_HAL);
     if (tryGet<MINT32>(meta, MTK_P2NODE_HIGH_SPEED_VDO_FPS, &fps) &&
         tryGet<MSize>(meta, MTK_P2NODE_HIGH_SPEED_VDO_SIZE, &size)) {
       MBOOL enable = fps && size.w && size.h;
       ret = configVencStream(enable, fps, size);
     }
   }
   TRACE_S_FUNC_EXIT(request->mLog);
   return ret;
 }

 MBOOL BasicProcessor::configVencStream(MBOOL enable, MINT32 fps, MSize size) {
   TRACE_S_FUNC_ENTER(mLog);
   MBOOL ret = MTRUE;
   if (enable != mEnableVencStream) {
     ret = enable ? mNormalStream->sendCommand(ESDCmd_CONFIG_VENC_DIRLK, fps,
                                               size.w, size.h)
                  : mNormalStream->sendCommand(ESDCmd_RELEASE_VENC_DIRLK);
     if (!ret) {
       MY_S_LOGW(mLog,
                 "Config venc stream failed: enable(%d) fps(%d) size(%dx%d)",
                 enable, fps, size.w, size.h);
     } else {
       mEnableVencStream = enable;
     }
   }
   TRACE_S_FUNC_EXIT(mLog);
   return ret;
 }

 BasicProcessor::P2Payload::P2Payload() {}

 BasicProcessor::P2Payload::P2Payload(const std::shared_ptr<P2Request>& request)
     : mRequest(request) {}

 BasicProcessor::P2Payload::~P2Payload() {
   P2Util::releaseTuning(&mTuning);
 }

 BasicProcessor::P2Cookie::P2Cookie(BasicProcessor* parent,
                                    const std::shared_ptr<P2Payload>& payload)
     : mParent(parent) {
   mPayloads.push_back(payload);
 }

 BasicProcessor::P2Cookie::P2Cookie(
     BasicProcessor* parent,
     const std::vector<std::shared_ptr<P2Payload>>& payloads)
     : mParent(parent), mPayloads(payloads) {}

 ILog BasicProcessor::P2Cookie::getILog() {
   ILog log;
   if (mPayloads.size() && mPayloads[0]->mRequest != nullptr) {
     log = mPayloads[0]->mRequest->mLog;
   }
   return log;
 }

 ILog BasicProcessor::getILog(const std::shared_ptr<P2Payload>& payload) {
   return payload->mRequest->mLog;
 }

 ILog BasicProcessor::getILog(
     const std::vector<std::shared_ptr<P2Payload>>& payloads) {
   return payloads[0]->mRequest->mLog;
 }

 template <typename T>
 MBOOL BasicProcessor::processP2(T payload) {
   ILog log = getILog(payload);
   TRACE_S_FUNC_ENTER(log);
   MBOOL ret = MFALSE;
   P2Cookie* cookie = createCookie(log, payload);
   if (cookie != nullptr) {
     P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:drv enq");
     QParams qparams = prepareEnqueQParams(payload);
     qparams.mpCookie = reinterpret_cast<void*>(cookie);
     qparams.mpfnCallback = BasicProcessor::p2CB;
     ret = mNormalStream->enque(&qparams);
     if (!ret) {
       MY_S_LOGW(log, "enque failed");
       updateResult(payload, MFALSE);
       freeCookie(cookie, NO_CHECK_ORDER);
     }
   }
   TRACE_S_FUNC_EXIT(log);
   return ret;
 }

 QParams BasicProcessor::prepareEnqueQParams(
     std::shared_ptr<P2Payload> payload) {
   TRACE_S_FUNC_ENTER(payload->mRequest->mLog);
   NSCam::Feature::P2Util::printQParams(getILog(payload), payload->mQParams);
   TRACE_S_FUNC_EXIT(payload->mRequest->mLog);
   return payload->mQParams;
 }

 QParams BasicProcessor::prepareEnqueQParams(
     std::vector<std::shared_ptr<P2Payload>> payloads) {
   TRACE_S_FUNC_ENTER(payloads[0]->mRequest->mLog);
   QParams qparams;
   for (std::shared_ptr<P2Payload> payload : payloads) {
     qparams.mvFrameParams.insert(qparams.mvFrameParams.end(),
                                  payload->mQParams.mvFrameParams.begin(),
                                  payload->mQParams.mvFrameParams.end());
   }
   TRACE_S_FUNC_EXIT(payloads[0]->mRequest->mLog);
   return qparams;
 }

 MVOID BasicProcessor::updateResult(std::shared_ptr<P2Payload> payload,
                                    MBOOL result) {
   TRACE_S_FUNC_ENTER(payload->mRequest->mLog);
   payload->mQParams.mDequeSuccess = result;
   payload->mRequest->updateResult(result);
   TRACE_S_FUNC_EXIT(payload->mRequest->mLog);
 }

 MVOID BasicProcessor::updateResult(
     std::vector<std::shared_ptr<P2Payload>> payloads, MBOOL result) {
   TRACE_S_FUNC_ENTER(payloads[0]->mRequest->mLog);
   for (std::shared_ptr<P2Payload> payload : payloads) {
     payload->mQParams.mDequeSuccess = result;
     payload->mRequest->updateResult(result);
   }
   TRACE_S_FUNC_EXIT(payloads[0]->mRequest->mLog);
 }

 MVOID BasicProcessor::processP2CB(const QParams& qparams, P2Cookie* cookie) {
   TRACE_S_FUNC_ENTER(mLog);
   if (cookie) {
     for (std::shared_ptr<P2Payload> payload : cookie->mPayloads) {
       payload->mQParams.mDequeSuccess = qparams.mDequeSuccess;
       onP2CB(payload->mQParams, payload);
     }
     freeCookie(cookie, CHECK_ORDER);
     cookie = nullptr;
   }
   TRACE_S_FUNC_EXIT(mLog);
 }

 template <typename T>
 BasicProcessor::P2Cookie* BasicProcessor::createCookie(const ILog& log,
                                                        const T& payload) {
   TRACE_S_FUNC_ENTER(log);
   P2Cookie* cookie = nullptr;
   cookie = new P2Cookie(this, payload);
   if (cookie == nullptr) {
     MY_S_LOGE(log, "OOM: cannot create P2Cookie");
   } else {
     std::lock_guard<std::mutex> _lock(mP2CookieMutex);
     mP2CookieList.push_back(cookie);
   }
   TRACE_S_FUNC_EXIT(log);
   return cookie;
 }

 MBOOL BasicProcessor::freeCookie(P2Cookie* cookie, MBOOL checkOrder) {
   TRACE_S_FUNC_ENTER(mLog);
   MBOOL ret = MFALSE;
   if (cookie == nullptr) {
     MY_S_LOGW(mLog, "invalid cookie = nullptr");
   } else {
     std::lock_guard<std::mutex> _lock(mP2CookieMutex);
     auto it = find(mP2CookieList.begin(), mP2CookieList.end(), cookie);
     if (it != mP2CookieList.end()) {
       if (checkOrder && it != mP2CookieList.begin()) {
         MY_S_LOGW(cookie->getILog(), "callback out of order");
       }
       delete cookie;
       cookie = nullptr;
       mP2CookieList.erase(it);
       mP2Condition.notify_all();
       ret = MTRUE;
     } else {
       MY_S_LOGE(mLog, "Cookie not freed: invalid data=%p", cookie);
     }
   }
   TRACE_S_FUNC_EXIT(mLog);
   return ret;
 }

 MVOID BasicProcessor::p2CB(QParams* pQparams) {
   TRACE_FUNC_ENTER();
   P2Cookie* cookie = reinterpret_cast<P2Cookie*>(pQparams->mpCookie);
   if (cookie && cookie->mParent) {
     cookie->mParent->processP2CB(*pQparams, cookie);
   }
   TRACE_FUNC_EXIT();
 }

 MVOID BasicProcessor::waitP2CBDone() {
   TRACE_S_FUNC_ENTER(mLog);
   std::unique_lock<std::mutex> _lock(mP2CookieMutex);
   while (mP2CookieList.size()) {
     mP2Condition.wait(_lock);
   }
   TRACE_S_FUNC_EXIT(mLog);
 }

 MBOOL BasicProcessor::processBurst(const std::shared_ptr<P2Payload>& payload) {
   TRACE_S_FUNC_ENTER(payload->mRequest->mLog);
   MUINT32 burst = payload->mRequest->mP2Pack.getConfigInfo().mBurstNum;
   burst = FORCE_BURST ? 4 : burst;
   burst = payload->mRequest->isResized() ? burst : 0;

   MUINT8 reqtSmvrFps = (MUINT8)MTK_SMVR_FPS_30;
   if (payload->mRequest != nullptr) {
     std::shared_ptr<P2Meta> spHalMeta = payload->mRequest->getMeta(IN_P1_HAL);
     if (tryGet<MUINT8>(spHalMeta, MTK_HAL_REQUEST_SMVR_FPS, &reqtSmvrFps)) {
       MY_LOGE("!!err: tryGet IN_P1_HAL error");
     }
   }

   if (reqtSmvrFps != (MUINT8)MTK_SMVR_FPS_30) {
     if (burst > 1) {
       mBurstQueue.push_back(payload);
     }
     if (mBurstQueue.size() && mBurstQueue.size() >= burst) {
       processP2(mBurstQueue);
       mBurstQueue.clear();
     }
   }
   TRACE_S_FUNC_EXIT(payload->mRequest->mLog,
                     "reqtSmvrFps=%d, burst(%d) queueSize(%d)", reqtSmvrFps,
                     burst, mBurstQueue.size());
   return (burst > 1 && reqtSmvrFps != MTK_SMVR_FPS_30);
 }

 MBOOL BasicProcessor::checkBurst() {
   TRACE_S_FUNC_ENTER(mLog);
   MBOOL ret = MFALSE;
   if (mBurstQueue.size()) {
     processP2(mBurstQueue);
     mBurstQueue.clear();
     ret = MTRUE;
   }
   TRACE_S_FUNC_EXIT(mLog);
   return ret;
 }

 }  // namespace P2
	/*
	* 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_BasicProcessor.h"
	#include "P2_Util.h"
	#include <src/pass2/NormalStream.h>

	#include <memory>
	#include <vector>

	#define LOG_TAG "P2_BasicProcessor"

	#define P2_BASIC_THREAD_NAME "p2_basic"
	#define FORCE_BURST 0

	namespace P2 {

	#include <mtkcam/utils/debug/P2_DebugControl.h>
	#define P2_CLASS_TAG BasicProcessor
	#define P2_TRACE TRACE_BASIC_PROCESSOR
	#include "P2_LogHeader.h"

	BasicProcessor::BasicProcessor() : Processor(P2_BASIC_THREAD_NAME) {
	MY_LOG_FUNC_ENTER();
	MY_LOG_FUNC_EXIT();
	}

	BasicProcessor::~BasicProcessor() {
	MY_LOG_S_FUNC_ENTER(mLog);
	this->uninit();
	MY_LOG_S_FUNC_EXIT(mLog);
	}

	MBOOL BasicProcessor::onInit(const P2InitParam& param) {
	ILog log = param.mP2Info.mLog;
	MY_LOG_S_FUNC_ENTER(log);
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:init()");

	MBOOL ret = MFALSE;

	mP2Info = param.mP2Info;
	mLog = mP2Info.mLog;
	ret = initNormalStream() && init3A();
	if (!ret) {
	MY_S_LOGE(mLog, "P2_Basic:init fail");
	uninitNormalStream();
	uninit3A();
	}

	MY_LOG_S_FUNC_EXIT(log);
	return ret;
	}

	MVOID BasicProcessor::onUninit() {
	MY_LOG_S_FUNC_ENTER(mLog);
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:uninit()");
	uninitNormalStream();
	uninit3A();
	MY_LOG_S_FUNC_EXIT(mLog);
	}

	MVOID BasicProcessor::onThreadStart() {
	MY_LOG_S_FUNC_ENTER(mLog);
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:threadStart()");
	MY_LOG_S_FUNC_EXIT(mLog);
	}

	MVOID BasicProcessor::onThreadStop() {
	MY_LOG_S_FUNC_ENTER(mLog);
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:threadStop()");
	MY_LOG_S_FUNC_EXIT(mLog);
	}

	MBOOL BasicProcessor::onConfig(const P2ConfigParam& param) {
	MY_LOG_S_FUNC_ENTER(mLog);
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:config()");
	mP2Info = param.mP2Info;
	MY_LOG_S_FUNC_EXIT(mLog);
	return MTRUE;
	}

	MBOOL BasicProcessor::onEnque(const std::shared_ptr<P2Request>& request) {
	ILog log = spToILog(request);
	TRACE_S_FUNC_ENTER(log);
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:enque()");
	MBOOL ret = MFALSE;

	processVenc(request);

	if (request != nullptr && request->hasInput() && request->hasOutput()) {
	std::shared_ptr<P2Payload> payload = std::make_shared<P2Payload>(request);
	MUINT32 portFlag = mEnableVencStream ? P2Util::USE_VENC : 0;
	payload->mIO = P2Util::extractSimpleIO(request, portFlag);
	payload->mIO.setUseLMV(MFALSE);

	if (payload->mIO.hasInput() && payload->mIO.hasOutput()) {
	P2MetaSet metaSet = request->getMetaSet();
	/add for tuning flow/
	int size = mTuningBuffers.size();
	payload->mIO.mTuningBuffer = mTuningBuffers[size - 1];
	payload->mTuning =
	P2Util::xmakeTuning(request->mP2Pack, payload->mIO, mHal3A, &metaSet);
	request->updateMetaSet(metaSet);
	payload->mQParams =
	P2Util::xmakeQParams(request->mP2Pack, payload->mIO, payload->mTuning,
	payload->mP2Obj.toPtrTable());
	mTuningBuffers.pop_back();

	payload->mRequest->releaseResource(P2Request::RES_IN_IMG);
	ret = processBurst(payload) \|\| processP2(payload);
	} else {
	checkBurst();
	}
	}

	TRACE_S_FUNC_EXIT(log);
	return ret;
	}

	MVOID BasicProcessor::onNotifyFlush() {
	MY_LOG_S_FUNC_ENTER(mLog);
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:notifyFlush()");
	if (mBurstQueue.size()) {
	updateResult(mBurstQueue, MFALSE);
	mBurstQueue.clear();
	}
	MY_LOG_S_FUNC_EXIT(mLog);
	}

	MVOID BasicProcessor::onWaitFlush() {
	MY_LOG_S_FUNC_ENTER(mLog);
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:waitFlush()");
	waitP2CBDone();
	MY_LOG_S_FUNC_EXIT(mLog);
	}

	MBOOL BasicProcessor::initNormalStream() {
	TRACE_S_FUNC_ENTER(mLog);
	MBOOL ret = MFALSE;

	P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "P2_Basic:NormalStream create");
	mNormalStream = std::make_shared<NSCam::v4l2::NormalStream>(
	mP2Info.getConfigInfo().mMainSensorID);
	P2_CAM_TRACE_END(TRACE_ADVANCED);
	if (mNormalStream == nullptr) {
	MY_S_LOGE(mLog, "OOM: cannot create NormalStream");
	} else {
	P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "P2_Basic:NormalStream init");
	ret = mNormalStream->init(getName());
	P2_CAM_TRACE_END(TRACE_ADVANCED);
	if (!ret) {
	MY_S_LOGE(mLog, "NormalStream init failed");
	return MFALSE;
	}
	ret = mNormalStream->requestBuffers(
	NSImageio::NSIspio::EPortIndex_TUNING,
	NSCam::IImageBufferAllocator::ImgParam(0, 0), &mTuningBuffers);
	if (!ret) {
	MY_S_LOGE(mLog, "NormalStream requestBuffers failed");
	}
	}
	TRACE_S_FUNC_EXIT(mLog);
	return ret;
	}

	MVOID BasicProcessor::uninitNormalStream() {
	TRACE_S_FUNC_ENTER(mLog);
	if (mNormalStream) {
	configVencStream(MFALSE);
	for (auto& it : mTuningBuffers) {
	it->unlockBuf("V4L2");
	}
	mNormalStream->uninit(getName());
	}
	TRACE_S_FUNC_EXIT(mLog);
	}

	MBOOL BasicProcessor::init3A() {
	TRACE_S_FUNC_ENTER(mLog);
	MBOOL ret = MTRUE;
	P2_CAM_TRACE_BEGIN(TRACE_ADVANCED, "P2_Basic:3A create");
	MAKE_Hal3A(
	mHal3A, [](IHal3A* p) { p->destroyInstance(LOG_TAG); },
	mP2Info.getConfigInfo().mMainSensorID, LOG_TAG);

	P2_CAM_TRACE_END(TRACE_ADVANCED);
	if (mHal3A == nullptr) {
	MY_S_LOGE(mLog, "OOM: cannot create Hal3A");
	ret = MFALSE;
	}
	TRACE_S_FUNC_EXIT(mLog);
	return ret;
	}

	MVOID BasicProcessor::uninit3A() {
	TRACE_S_FUNC_ENTER(mLog);
	TRACE_S_FUNC_EXIT(mLog);
	}

	MVOID BasicProcessor::onP2CB(const QParams& qparams,
	std::shared_ptr<P2Payload> const& payload) {
	TRACE_S_FUNC_ENTER(payload->mRequest->mLog);
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:onP2CB()");
	std::shared_ptr<IImageBuffer> tuningBuffer = payload->mIO.mTuningBuffer;
	mTuningBuffers.push_back(tuningBuffer);
	payload->mIO.updateResult(qparams.mDequeSuccess);
	}

	MBOOL BasicProcessor::processVenc(const std::shared_ptr<P2Request>& request) {
	TRACE_S_FUNC_ENTER(request->mLog);
	MBOOL ret = MTRUE;
	if (request != nullptr) {
	MINT32 fps = 0;
	MSize size;
	std::shared_ptr<P2Meta> meta = request->getMeta(IN_P1_HAL);
	if (tryGet<MINT32>(meta, MTK_P2NODE_HIGH_SPEED_VDO_FPS, &fps) &&
	tryGet<MSize>(meta, MTK_P2NODE_HIGH_SPEED_VDO_SIZE, &size)) {
	MBOOL enable = fps && size.w && size.h;
	ret = configVencStream(enable, fps, size);
	}
	}
	TRACE_S_FUNC_EXIT(request->mLog);
	return ret;
	}

	MBOOL BasicProcessor::configVencStream(MBOOL enable, MINT32 fps, MSize size) {
	TRACE_S_FUNC_ENTER(mLog);
	MBOOL ret = MTRUE;
	if (enable != mEnableVencStream) {
	ret = enable ? mNormalStream->sendCommand(ESDCmd_CONFIG_VENC_DIRLK, fps,
	size.w, size.h)
	: mNormalStream->sendCommand(ESDCmd_RELEASE_VENC_DIRLK);
	if (!ret) {
	MY_S_LOGW(mLog,
	"Config venc stream failed: enable(%d) fps(%d) size(%dx%d)",
	enable, fps, size.w, size.h);
	} else {
	mEnableVencStream = enable;
	}
	}
	TRACE_S_FUNC_EXIT(mLog);
	return ret;
	}

	BasicProcessor::P2Payload::P2Payload() {}

	BasicProcessor::P2Payload::P2Payload(const std::shared_ptr<P2Request>& request)
	: mRequest(request) {}

	BasicProcessor::P2Payload::~P2Payload() {
	P2Util::releaseTuning(&mTuning);
	}

	BasicProcessor::P2Cookie::P2Cookie(BasicProcessor* parent,
	const std::shared_ptr<P2Payload>& payload)
	: mParent(parent) {
	mPayloads.push_back(payload);
	}

	BasicProcessor::P2Cookie::P2Cookie(
	BasicProcessor* parent,
	const std::vector<std::shared_ptr<P2Payload>>& payloads)
	: mParent(parent), mPayloads(payloads) {}

	ILog BasicProcessor::P2Cookie::getILog() {
	ILog log;
	if (mPayloads.size() && mPayloads[0]->mRequest != nullptr) {
	log = mPayloads[0]->mRequest->mLog;
	}
	return log;
	}

	ILog BasicProcessor::getILog(const std::shared_ptr<P2Payload>& payload) {
	return payload->mRequest->mLog;
	}

	ILog BasicProcessor::getILog(
	const std::vector<std::shared_ptr<P2Payload>>& payloads) {
	return payloads[0]->mRequest->mLog;
	}

	template <typename T>
	MBOOL BasicProcessor::processP2(T payload) {
	ILog log = getILog(payload);
	TRACE_S_FUNC_ENTER(log);
	MBOOL ret = MFALSE;
	P2Cookie* cookie = createCookie(log, payload);
	if (cookie != nullptr) {
	P2_CAM_TRACE_NAME(TRACE_ADVANCED, "P2_Basic:drv enq");
	QParams qparams = prepareEnqueQParams(payload);
	qparams.mpCookie = reinterpret_cast<void*>(cookie);
	qparams.mpfnCallback = BasicProcessor::p2CB;
	ret = mNormalStream->enque(&qparams);
	if (!ret) {
	MY_S_LOGW(log, "enque failed");
	updateResult(payload, MFALSE);
	freeCookie(cookie, NO_CHECK_ORDER);
	}
	}
	TRACE_S_FUNC_EXIT(log);
	return ret;
	}

	QParams BasicProcessor::prepareEnqueQParams(
	std::shared_ptr<P2Payload> payload) {
	TRACE_S_FUNC_ENTER(payload->mRequest->mLog);
	NSCam::Feature::P2Util::printQParams(getILog(payload), payload->mQParams);
	TRACE_S_FUNC_EXIT(payload->mRequest->mLog);
	return payload->mQParams;
	}

	QParams BasicProcessor::prepareEnqueQParams(
	std::vector<std::shared_ptr<P2Payload>> payloads) {
	TRACE_S_FUNC_ENTER(payloads[0]->mRequest->mLog);
	QParams qparams;
	for (std::shared_ptr<P2Payload> payload : payloads) {
	qparams.mvFrameParams.insert(qparams.mvFrameParams.end(),
	payload->mQParams.mvFrameParams.begin(),
	payload->mQParams.mvFrameParams.end());
	}
	TRACE_S_FUNC_EXIT(payloads[0]->mRequest->mLog);
	return qparams;
	}

	MVOID BasicProcessor::updateResult(std::shared_ptr<P2Payload> payload,
	MBOOL result) {
	TRACE_S_FUNC_ENTER(payload->mRequest->mLog);
	payload->mQParams.mDequeSuccess = result;
	payload->mRequest->updateResult(result);
	TRACE_S_FUNC_EXIT(payload->mRequest->mLog);
	}

	MVOID BasicProcessor::updateResult(
	std::vector<std::shared_ptr<P2Payload>> payloads, MBOOL result) {
	TRACE_S_FUNC_ENTER(payloads[0]->mRequest->mLog);
	for (std::shared_ptr<P2Payload> payload : payloads) {
	payload->mQParams.mDequeSuccess = result;
	payload->mRequest->updateResult(result);
	}
	TRACE_S_FUNC_EXIT(payloads[0]->mRequest->mLog);
	}

	MVOID BasicProcessor::processP2CB(const QParams& qparams, P2Cookie* cookie) {
	TRACE_S_FUNC_ENTER(mLog);
	if (cookie) {
	for (std::shared_ptr<P2Payload> payload : cookie->mPayloads) {
	payload->mQParams.mDequeSuccess = qparams.mDequeSuccess;
	onP2CB(payload->mQParams, payload);
	}
	freeCookie(cookie, CHECK_ORDER);
	cookie = nullptr;
	}
	TRACE_S_FUNC_EXIT(mLog);
	}

	template <typename T>
	BasicProcessor::P2Cookie* BasicProcessor::createCookie(const ILog& log,
	const T& payload) {
	TRACE_S_FUNC_ENTER(log);
	P2Cookie* cookie = nullptr;
	cookie = new P2Cookie(this, payload);
	if (cookie == nullptr) {
	MY_S_LOGE(log, "OOM: cannot create P2Cookie");
	} else {
	std::lock_guard<std::mutex> _lock(mP2CookieMutex);
	mP2CookieList.push_back(cookie);
	}
	TRACE_S_FUNC_EXIT(log);
	return cookie;
	}

	MBOOL BasicProcessor::freeCookie(P2Cookie* cookie, MBOOL checkOrder) {
	TRACE_S_FUNC_ENTER(mLog);
	MBOOL ret = MFALSE;
	if (cookie == nullptr) {
	MY_S_LOGW(mLog, "invalid cookie = nullptr");
	} else {
	std::lock_guard<std::mutex> _lock(mP2CookieMutex);
	auto it = find(mP2CookieList.begin(), mP2CookieList.end(), cookie);
	if (it != mP2CookieList.end()) {
	if (checkOrder && it != mP2CookieList.begin()) {
	MY_S_LOGW(cookie->getILog(), "callback out of order");
	}
	delete cookie;
	cookie = nullptr;
	mP2CookieList.erase(it);
	mP2Condition.notify_all();
	ret = MTRUE;
	} else {
	MY_S_LOGE(mLog, "Cookie not freed: invalid data=%p", cookie);
	}
	}
	TRACE_S_FUNC_EXIT(mLog);
	return ret;
	}

	MVOID BasicProcessor::p2CB(QParams* pQparams) {
	TRACE_FUNC_ENTER();
	P2Cookie* cookie = reinterpret_cast<P2Cookie*>(pQparams->mpCookie);
	if (cookie && cookie->mParent) {
	cookie->mParent->processP2CB(*pQparams, cookie);
	}
	TRACE_FUNC_EXIT();
	}

	MVOID BasicProcessor::waitP2CBDone() {
	TRACE_S_FUNC_ENTER(mLog);
	std::unique_lock<std::mutex> _lock(mP2CookieMutex);
	while (mP2CookieList.size()) {
	mP2Condition.wait(_lock);
	}
	TRACE_S_FUNC_EXIT(mLog);
	}

	MBOOL BasicProcessor::processBurst(const std::shared_ptr<P2Payload>& payload) {
	TRACE_S_FUNC_ENTER(payload->mRequest->mLog);
	MUINT32 burst = payload->mRequest->mP2Pack.getConfigInfo().mBurstNum;
	burst = FORCE_BURST ? 4 : burst;
	burst = payload->mRequest->isResized() ? burst : 0;

	MUINT8 reqtSmvrFps = (MUINT8)MTK_SMVR_FPS_30;
	if (payload->mRequest != nullptr) {
	std::shared_ptr<P2Meta> spHalMeta = payload->mRequest->getMeta(IN_P1_HAL);
	if (tryGet<MUINT8>(spHalMeta, MTK_HAL_REQUEST_SMVR_FPS, &reqtSmvrFps)) {
	MY_LOGE("!!err: tryGet IN_P1_HAL error");
	}
	}

	if (reqtSmvrFps != (MUINT8)MTK_SMVR_FPS_30) {
	if (burst > 1) {
	mBurstQueue.push_back(payload);
	}
	if (mBurstQueue.size() && mBurstQueue.size() >= burst) {
	processP2(mBurstQueue);
	mBurstQueue.clear();
	}
	}
	TRACE_S_FUNC_EXIT(payload->mRequest->mLog,
	"reqtSmvrFps=%d, burst(%d) queueSize(%d)", reqtSmvrFps,
	burst, mBurstQueue.size());
	return (burst > 1 && reqtSmvrFps != MTK_SMVR_FPS_30);
	}

	MBOOL BasicProcessor::checkBurst() {
	TRACE_S_FUNC_ENTER(mLog);
	MBOOL ret = MFALSE;
	if (mBurstQueue.size()) {
	processP2(mBurstQueue);
	mBurstQueue.clear();
	ret = MTRUE;
	}
	TRACE_S_FUNC_EXIT(mLog);
	return ret;
	}

	} // namespace P2