camera/hal/mediatek/mtkcam/pipeline/hwnode/p2/P2_Param.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_Param.h"

 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>

 using NSCam::TuningUtils::FILE_DUMP_NAMING_HINT;
 using NSCam::TuningUtils::RAW_PORT_IMGO;
 using NSCam::TuningUtils::RAW_PORT_RRZO;
 using NSCam::TuningUtils::YUV_PORT_UNDEFINED;
 using NSCam::TuningUtils::YUV_PORT_WDMAO;
 using NSCam::TuningUtils::YUV_PORT_WROTO;

 namespace P2 {

 #define META_INFO_1(id, dir, name, flag) \
   { id, META_INFO(id, id, dir, name, flag) }
 #define META_INFO_2(id, dir, name, flag) \
   { id##_2, META_INFO(id##_2, id, dir, name "_2", flag) }

 #define IMG_INFO_1(id, dir, name, flag) \
   { id, IMG_INFO(id, id, dir, name, flag) }
 #define IMG_INFO_2(id, dir, name, flag) \
   { id##_2, IMG_INFO(id##_2, id, dir, name "_2", flag) }

 META_INFO::META_INFO() {}

 META_INFO::META_INFO(ID_META sID,
                      ID_META sMirror,
                      IO_DIR sDir,
                      const std::string& sName,
                      MUINT32 sFlag)
     : id(sID), mirror(sMirror), dir(sDir), name(sName), flag(sFlag) {}

 IMG_INFO::IMG_INFO() {}

 IMG_INFO::IMG_INFO(ID_IMG sID,
                    ID_IMG sMirror,
                    IO_DIR sDir,
                    const std::string& sName,
                    MUINT32 sFlag)
     : id(sID), mirror(sMirror), dir(sDir), name(sName), flag(sFlag) {}

 const std::unordered_map<ID_META, META_INFO> P2Meta::InfoMap = {
     META_INFO_1(IN_APP, IO_DIR_IN, "inApp", IO_FLAG_DEFAULT),
     META_INFO_1(IN_P1_APP, IO_DIR_IN, "inP1App", IO_FLAG_COPY),
     META_INFO_1(IN_P1_HAL, IO_DIR_IN, "inP1Hal", IO_FLAG_COPY),
     META_INFO_1(OUT_APP, IO_DIR_OUT, "outApp", IO_FLAG_DEFAULT),
     META_INFO_1(OUT_HAL, IO_DIR_OUT, "outHal", IO_FLAG_DEFAULT),

     META_INFO_2(IN_P1_APP, IO_DIR_IN, "inP1App", IO_FLAG_COPY),
     META_INFO_2(IN_P1_HAL, IO_DIR_IN, "inP1Hal", IO_FLAG_COPY),
 };

 const std::unordered_map<ID_IMG, IMG_INFO> P2Img::InfoMap = {
     IMG_INFO_1(IN_REPROCESS, IO_DIR_IN, "inReprocess", IO_FLAG_DEFAULT),
     IMG_INFO_1(IN_OPAQUE, IO_DIR_IN, "inOpaque", IO_FLAG_DEFAULT),
     IMG_INFO_1(IN_FULL, IO_DIR_IN, "inFull", IO_FLAG_DEFAULT),
     IMG_INFO_1(IN_RESIZED, IO_DIR_IN, "inResized", IO_FLAG_DEFAULT),
     IMG_INFO_1(IN_LCSO, IO_DIR_IN, "inLCSO", IO_FLAG_DEFAULT),
     IMG_INFO_1(IN_RSSO, IO_DIR_IN, "inRSSO", IO_FLAG_DEFAULT),
     IMG_INFO_1(OUT_FD, IO_DIR_OUT, "outFD", IO_FLAG_DEFAULT),
     IMG_INFO_1(OUT_THN_YUV, IO_DIR_OUT, "outThumbnailYUV", IO_FLAG_DEFAULT),
     IMG_INFO_1(OUT_JPEG_YUV, IO_DIR_OUT, "outJpegYUV", IO_FLAG_DEFAULT),
     IMG_INFO_1(OUT_YUV, IO_DIR_OUT, "outYUV", IO_FLAG_DEFAULT),
     IMG_INFO_1(OUT_POSTVIEW, IO_DIR_OUT, "outPostView", IO_FLAG_DEFAULT),

     IMG_INFO_2(IN_OPAQUE, IO_DIR_IN, "inOpaque", IO_FLAG_DEFAULT),
     IMG_INFO_2(IN_FULL, IO_DIR_IN, "inFull", IO_FLAG_DEFAULT),
     IMG_INFO_2(IN_RESIZED, IO_DIR_IN, "inResized", IO_FLAG_DEFAULT),
     IMG_INFO_2(IN_LCSO, IO_DIR_IN, "inLCSO", IO_FLAG_DEFAULT),
     IMG_INFO_2(IN_RSSO, IO_DIR_IN, "inRSSO", IO_FLAG_DEFAULT),
 };

 const std::unordered_map<ID_META, ID_META> P2InIDMap::MainMeta = {
     {IN_APP, IN_APP},
     {IN_P1_APP, IN_P1_APP},
     {IN_P1_HAL, IN_P1_HAL},
 };

 const std::unordered_map<ID_IMG, ID_IMG> P2InIDMap::MainImg = {
     {IN_REPROCESS, IN_REPROCESS}, {IN_OPAQUE, IN_OPAQUE}, {IN_FULL, IN_FULL},
     {IN_RESIZED, IN_RESIZED},     {IN_LCSO, IN_LCSO},     {IN_RSSO, IN_RSSO},
 };

 const std::unordered_map<ID_META, ID_META> P2InIDMap::SubMeta = {
     {IN_APP, IN_APP},
     {IN_P1_APP, IN_P1_APP_2},
     {IN_P1_HAL, IN_P1_HAL_2},
 };

 const std::unordered_map<ID_IMG, ID_IMG> P2InIDMap::SubImg = {
     {IN_REPROCESS, IN_REPROCESS}, {IN_OPAQUE, IN_OPAQUE_2},
     {IN_FULL, IN_FULL_2},         {IN_RESIZED, IN_RESIZED_2},
     {IN_LCSO, IN_LCSO_2},         {IN_RSSO, IN_RSSO_2},
 };

 P2InIDMap::P2InIDMap(const std::vector<MUINT32>& sensorIDList,
                      const MUINT32 mainSensorID)
     : mMainSensorID(mainSensorID) {
   for (MUINT32 sId : sensorIDList) {
     if (sId == mainSensorID) {
       mSensor2MetaID[sId] = MainMeta;
       mSensor2ImgID[sId] = MainImg;
     } else {
       // TODO(mtk): If more than 2 sensors, need add logic here
       mSensor2MetaID[sId] = SubMeta;
       mSensor2ImgID[sId] = SubImg;
     }
   }
 }

 ID_META P2InIDMap::getMetaID(const MUINT32 sensorID, const ID_META inID) {
   return mSensor2MetaID[sensorID][inID];
 }
 ID_IMG P2InIDMap::getImgID(const MUINT32 sensorID, const ID_IMG inID) {
   return mSensor2ImgID[sensorID][inID];
 }

 MBOOL P2InIDMap::isEmpty(const MUINT32 sensorID) {
   return (mSensor2ImgID[sensorID].empty() || mSensor2MetaID[sensorID].empty());
 }

 const META_INFO& P2Meta::getMetaInfo(ID_META id) {
   static const META_INFO sInvalid = {ID_META_INVALID, ID_META_INVALID,
                                      IO_DIR_UNKNOWN, "invalid",
                                      IO_FLAG_INVALID};

   auto it = P2Meta::InfoMap.find(id);
   return (it != P2Meta::InfoMap.end()) ? it->second : sInvalid;
 }

 const IMG_INFO& P2Img::getImgInfo(ID_IMG id) {
   static const IMG_INFO sInvalid = {ID_IMG_INVALID, ID_IMG_INVALID,
                                     IO_DIR_UNKNOWN, "invalid", IO_FLAG_INVALID};

   auto it = P2Img::InfoMap.find(id);
   return (it != P2Img::InfoMap.end()) ? it->second : sInvalid;
 }

 const char* P2Meta::getName(ID_META id) {
   const char* name = "unknown";
   auto it = P2Meta::InfoMap.find(id);
   if (it != P2Meta::InfoMap.end()) {
     name = it->second.name.c_str();
   }
   return name;
 }

 const char* P2Img::getName(ID_IMG id) {
   const char* name = "unknown";
   auto it = P2Img::InfoMap.find(id);
   if (it != P2Img::InfoMap.end()) {
     name = it->second.name.c_str();
   }
   return name;
 }

 P2MetaSet::P2MetaSet() : mHasOutput(MFALSE) {}

 P2Meta::P2Meta(const ILog& log, const P2Pack& p2Pack, ID_META id)
     : mLog(log), mP2Pack(p2Pack), mMetaID(id) {}

 ID_META P2Meta::getID() const {
   return mMetaID;
 }

 #define P2_CLASS_TAG P2Img
 #define P2_TRACE TRACE_P2_IMG
 #include "P2_LogHeader.h"

 P2Img::P2Img(const ILog& log,
              const P2Pack& p2Pack,
              ID_IMG id,
              MUINT32 debugIndex)
     : mLog(log), mP2Pack(p2Pack), mImgID(id), mDebugIndex(debugIndex) {}

 ID_IMG P2Img::getID() const {
   return mImgID;
 }

 const char* P2Img::getHumanName() const {
   const char* name = getName(mImgID);
   if (mImgID == OUT_FD) {
     name = "fd";
   } else if (mImgID == OUT_YUV) {
     name = isDisplay() ? "display" : isRecord() ? "record" : "previewCB";
   }
   return name;
 }

 MSize P2Img::getImgSize() const {
   MSize size(0, 0);
   if (isValid()) {
     IImageBuffer* img = getIImageBufferPtr();
     if (img) {
       size = img->getImgSize();
     }
   }
   return size;
 }

 MSize P2Img::getTransformSize() const {
   MSize size(0, 0);
   if (isValid()) {
     IImageBuffer* img = getIImageBufferPtr();
     if (img) {
       size = img->getImgSize();
       if (getTransform() & eTransform_ROT_90) {
         size = MSize(size.h, size.w);
       }
     }
   }
   return size;
 }

 const char* P2Img::Fmt2Name(MINT fmt) {
   switch (fmt) {
     case NSCam::eImgFmt_RGBA8888:
       return "rgba";
     case NSCam::eImgFmt_RGB888:
       return "rgb";
     case NSCam::eImgFmt_RGB565:
       return "rgb565";
     case NSCam::eImgFmt_STA_BYTE:
       return "byte";
     case NSCam::eImgFmt_YVYU:
       return "yvyu";
     case NSCam::eImgFmt_UYVY:
       return "uyvy";
     case NSCam::eImgFmt_VYUY:
       return "vyuy";
     case NSCam::eImgFmt_YUY2:
       return "yuy2";
     case NSCam::eImgFmt_YV12:
       return "yv12";
     case NSCam::eImgFmt_YV16:
       return "yv16";
     case NSCam::eImgFmt_NV16:
       return "nv16";
     case NSCam::eImgFmt_NV61:
       return "nv61";
     case NSCam::eImgFmt_NV12:
       return "nv12";
     case NSCam::eImgFmt_NV21:
       return "nv21";
     case NSCam::eImgFmt_I420:
       return "i420";
     case NSCam::eImgFmt_I422:
       return "i422";
     case NSCam::eImgFmt_Y800:
       return "y800";
     case NSCam::eImgFmt_BAYER8:
       return "bayer8";
     case NSCam::eImgFmt_BAYER10:
       return "bayer10";
     case NSCam::eImgFmt_BAYER12:
       return "bayer12";
     case NSCam::eImgFmt_BAYER14:
       return "bayer14";
     case NSCam::eImgFmt_FG_BAYER8:
       return "fg_bayer8";
     case NSCam::eImgFmt_FG_BAYER10:
       return "fg_bayer10";
     case NSCam::eImgFmt_FG_BAYER12:
       return "fg_bayer12";
     case NSCam::eImgFmt_FG_BAYER14:
       return "fg_bayer14";
     default:
       return "unknown";
   }
 }

 MVOID P2Img::dumpBuffer() const {
   IImageBuffer* buffer = this->getIImageBufferPtr();
   if (buffer) {
     MUINT32 stride, pbpp, ibpp, width, height, size;
     MINT format = buffer->getImgFormat();
     stride = buffer->getBufStridesInBytes(0);
     pbpp = buffer->getPlaneBitsPerPixel(0);
     ibpp = buffer->getImgBitsPerPixel();
     size = buffer->getBufSizeInBytes(0);
     pbpp = pbpp ? pbpp : 8;
     width = stride * 8 / pbpp;
     width = width ? width : 1;
     ibpp = ibpp ? ibpp : 8;
     height = size / width;
     if (buffer->getPlaneCount() == 1) {
       height = height * 8 / ibpp;
     }

     char path[256];
     snprintf(path, sizeof(path), DUMP_PATH "/%04d_%02d_%s_%dx%d_%d.%s.bin",
              mLog.getLogFrameID(), mDebugIndex, getHumanName(), width, height,
              stride, Fmt2Name(format));
     buffer->saveToFile(path);
   }
 }

 MVOID P2Img::dumpNddBuffer() const {
   IImageBuffer* buffer = this->getIImageBufferPtr();
   if (buffer) {
     char filename[256] = {0};

     IMG_INFO info = getImgInfo(mImgID);

     FILE_DUMP_NAMING_HINT hint;
     hint = mP2Pack.getSensorData().mNDDHint;
     extract(&hint, buffer);

     switch (info.mirror) {
       case IN_FULL:
         genFileName_RAW(filename, sizeof(filename), &hint, RAW_PORT_IMGO);
         break;

       case IN_FULL_2:
         genFileName_RAW(filename, sizeof(filename), &hint, RAW_PORT_IMGO,
                         info.name.c_str());
         break;

       case IN_RESIZED:
         genFileName_RAW(filename, sizeof(filename), &hint, RAW_PORT_RRZO);
         break;

       case IN_RESIZED_2:
         genFileName_RAW(filename, sizeof(filename), &hint, RAW_PORT_RRZO,
                         info.name.c_str());
         break;

       case IN_LCSO:
         genFileName_LCSO(filename, sizeof(filename), &hint);
         break;

       case IN_LCSO_2:
         genFileName_LCSO(filename, sizeof(filename), &hint, info.name.c_str());
         break;

       case OUT_YUV: {
         if (this->isDisplay()) {
           genFileName_YUV(filename, sizeof(filename), &hint, YUV_PORT_WDMAO);
         } else if (this->isRecord()) {
           genFileName_YUV(filename, sizeof(filename), &hint, YUV_PORT_WROTO);
         } else {
           genFileName_YUV(filename, sizeof(filename), &hint,
                           YUV_PORT_UNDEFINED);
         }
       } break;
       default:
         break;
     }

     if (filename[0]) {
       MY_S_LOGD(mP2Pack.mLog, "dump to: %s", filename);
       buffer->saveToFile(filename);
     }
   }
 }

 MINT32 P2Img::getMagic3A() const {
   return mP2Pack.getSensorData().mMagic3A;
 }

 MBOOL P2ImgPlugin::onPlugin(const std::shared_ptr<P2Img>& img) {
   return onPlugin(img.get());
 }

 MBOOL isValid(const P2Meta* meta) {
   return (meta != nullptr) && meta->isValid();
 }

 MBOOL isValid(const P2Img* img) {
   return (img != nullptr) && img->isValid();
 }

 MBOOL isValid(const std::shared_ptr<P2Meta>& meta) {
   return (meta != nullptr) && meta->isValid();
 }

 MBOOL isValid(const std::shared_ptr<P2Img>& img) {
   return (img != nullptr) && img->isValid();
 }

 IMetadata* toIMetadataPtr(const std::shared_ptr<P2Meta>& meta) {
   return meta != nullptr ? meta->getIMetadataPtr() : nullptr;
 }

 IImageBuffer* toIImageBufferPtr(const std::shared_ptr<P2Img>& img) {
   return img != nullptr ? img->getIImageBufferPtr() : nullptr;
 }

 }  // 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_Param.h"

	#include <memory>
	#include <string>
	#include <unordered_map>
	#include <vector>

	using NSCam::TuningUtils::FILE_DUMP_NAMING_HINT;
	using NSCam::TuningUtils::RAW_PORT_IMGO;
	using NSCam::TuningUtils::RAW_PORT_RRZO;
	using NSCam::TuningUtils::YUV_PORT_UNDEFINED;
	using NSCam::TuningUtils::YUV_PORT_WDMAO;
	using NSCam::TuningUtils::YUV_PORT_WROTO;

	namespace P2 {

	#define META_INFO_1(id, dir, name, flag) \
	{ id, META_INFO(id, id, dir, name, flag) }
	#define META_INFO_2(id, dir, name, flag) \
	{ id##_2, META_INFO(id##_2, id, dir, name "_2", flag) }

	#define IMG_INFO_1(id, dir, name, flag) \
	{ id, IMG_INFO(id, id, dir, name, flag) }
	#define IMG_INFO_2(id, dir, name, flag) \
	{ id##_2, IMG_INFO(id##_2, id, dir, name "_2", flag) }

	META_INFO::META_INFO() {}

	META_INFO::META_INFO(ID_META sID,
	ID_META sMirror,
	IO_DIR sDir,
	const std::string& sName,
	MUINT32 sFlag)
	: id(sID), mirror(sMirror), dir(sDir), name(sName), flag(sFlag) {}

	IMG_INFO::IMG_INFO() {}

	IMG_INFO::IMG_INFO(ID_IMG sID,
	ID_IMG sMirror,
	IO_DIR sDir,
	const std::string& sName,
	MUINT32 sFlag)
	: id(sID), mirror(sMirror), dir(sDir), name(sName), flag(sFlag) {}

	const std::unordered_map<ID_META, META_INFO> P2Meta::InfoMap = {
	META_INFO_1(IN_APP, IO_DIR_IN, "inApp", IO_FLAG_DEFAULT),
	META_INFO_1(IN_P1_APP, IO_DIR_IN, "inP1App", IO_FLAG_COPY),
	META_INFO_1(IN_P1_HAL, IO_DIR_IN, "inP1Hal", IO_FLAG_COPY),
	META_INFO_1(OUT_APP, IO_DIR_OUT, "outApp", IO_FLAG_DEFAULT),
	META_INFO_1(OUT_HAL, IO_DIR_OUT, "outHal", IO_FLAG_DEFAULT),

	META_INFO_2(IN_P1_APP, IO_DIR_IN, "inP1App", IO_FLAG_COPY),
	META_INFO_2(IN_P1_HAL, IO_DIR_IN, "inP1Hal", IO_FLAG_COPY),
	};

	const std::unordered_map<ID_IMG, IMG_INFO> P2Img::InfoMap = {
	IMG_INFO_1(IN_REPROCESS, IO_DIR_IN, "inReprocess", IO_FLAG_DEFAULT),
	IMG_INFO_1(IN_OPAQUE, IO_DIR_IN, "inOpaque", IO_FLAG_DEFAULT),
	IMG_INFO_1(IN_FULL, IO_DIR_IN, "inFull", IO_FLAG_DEFAULT),
	IMG_INFO_1(IN_RESIZED, IO_DIR_IN, "inResized", IO_FLAG_DEFAULT),
	IMG_INFO_1(IN_LCSO, IO_DIR_IN, "inLCSO", IO_FLAG_DEFAULT),
	IMG_INFO_1(IN_RSSO, IO_DIR_IN, "inRSSO", IO_FLAG_DEFAULT),
	IMG_INFO_1(OUT_FD, IO_DIR_OUT, "outFD", IO_FLAG_DEFAULT),
	IMG_INFO_1(OUT_THN_YUV, IO_DIR_OUT, "outThumbnailYUV", IO_FLAG_DEFAULT),
	IMG_INFO_1(OUT_JPEG_YUV, IO_DIR_OUT, "outJpegYUV", IO_FLAG_DEFAULT),
	IMG_INFO_1(OUT_YUV, IO_DIR_OUT, "outYUV", IO_FLAG_DEFAULT),
	IMG_INFO_1(OUT_POSTVIEW, IO_DIR_OUT, "outPostView", IO_FLAG_DEFAULT),

	IMG_INFO_2(IN_OPAQUE, IO_DIR_IN, "inOpaque", IO_FLAG_DEFAULT),
	IMG_INFO_2(IN_FULL, IO_DIR_IN, "inFull", IO_FLAG_DEFAULT),
	IMG_INFO_2(IN_RESIZED, IO_DIR_IN, "inResized", IO_FLAG_DEFAULT),
	IMG_INFO_2(IN_LCSO, IO_DIR_IN, "inLCSO", IO_FLAG_DEFAULT),
	IMG_INFO_2(IN_RSSO, IO_DIR_IN, "inRSSO", IO_FLAG_DEFAULT),
	};

	const std::unordered_map<ID_META, ID_META> P2InIDMap::MainMeta = {
	{IN_APP, IN_APP},
	{IN_P1_APP, IN_P1_APP},
	{IN_P1_HAL, IN_P1_HAL},
	};

	const std::unordered_map<ID_IMG, ID_IMG> P2InIDMap::MainImg = {
	{IN_REPROCESS, IN_REPROCESS}, {IN_OPAQUE, IN_OPAQUE}, {IN_FULL, IN_FULL},
	{IN_RESIZED, IN_RESIZED}, {IN_LCSO, IN_LCSO}, {IN_RSSO, IN_RSSO},
	};

	const std::unordered_map<ID_META, ID_META> P2InIDMap::SubMeta = {
	{IN_APP, IN_APP},
	{IN_P1_APP, IN_P1_APP_2},
	{IN_P1_HAL, IN_P1_HAL_2},
	};

	const std::unordered_map<ID_IMG, ID_IMG> P2InIDMap::SubImg = {
	{IN_REPROCESS, IN_REPROCESS}, {IN_OPAQUE, IN_OPAQUE_2},
	{IN_FULL, IN_FULL_2}, {IN_RESIZED, IN_RESIZED_2},
	{IN_LCSO, IN_LCSO_2}, {IN_RSSO, IN_RSSO_2},
	};

	P2InIDMap::P2InIDMap(const std::vector<MUINT32>& sensorIDList,
	const MUINT32 mainSensorID)
	: mMainSensorID(mainSensorID) {
	for (MUINT32 sId : sensorIDList) {
	if (sId == mainSensorID) {
	mSensor2MetaID[sId] = MainMeta;
	mSensor2ImgID[sId] = MainImg;
	} else {
	// TODO(mtk): If more than 2 sensors, need add logic here
	mSensor2MetaID[sId] = SubMeta;
	mSensor2ImgID[sId] = SubImg;
	}
	}
	}

	ID_META P2InIDMap::getMetaID(const MUINT32 sensorID, const ID_META inID) {
	return mSensor2MetaID[sensorID][inID];
	}
	ID_IMG P2InIDMap::getImgID(const MUINT32 sensorID, const ID_IMG inID) {
	return mSensor2ImgID[sensorID][inID];
	}

	MBOOL P2InIDMap::isEmpty(const MUINT32 sensorID) {
	return (mSensor2ImgID[sensorID].empty() \|\| mSensor2MetaID[sensorID].empty());
	}

	const META_INFO& P2Meta::getMetaInfo(ID_META id) {
	static const META_INFO sInvalid = {ID_META_INVALID, ID_META_INVALID,
	IO_DIR_UNKNOWN, "invalid",
	IO_FLAG_INVALID};

	auto it = P2Meta::InfoMap.find(id);
	return (it != P2Meta::InfoMap.end()) ? it->second : sInvalid;
	}

	const IMG_INFO& P2Img::getImgInfo(ID_IMG id) {
	static const IMG_INFO sInvalid = {ID_IMG_INVALID, ID_IMG_INVALID,
	IO_DIR_UNKNOWN, "invalid", IO_FLAG_INVALID};

	auto it = P2Img::InfoMap.find(id);
	return (it != P2Img::InfoMap.end()) ? it->second : sInvalid;
	}

	const char* P2Meta::getName(ID_META id) {
	const char* name = "unknown";
	auto it = P2Meta::InfoMap.find(id);
	if (it != P2Meta::InfoMap.end()) {
	name = it->second.name.c_str();
	}
	return name;
	}

	const char* P2Img::getName(ID_IMG id) {
	const char* name = "unknown";
	auto it = P2Img::InfoMap.find(id);
	if (it != P2Img::InfoMap.end()) {
	name = it->second.name.c_str();
	}
	return name;
	}

	P2MetaSet::P2MetaSet() : mHasOutput(MFALSE) {}

	P2Meta::P2Meta(const ILog& log, const P2Pack& p2Pack, ID_META id)
	: mLog(log), mP2Pack(p2Pack), mMetaID(id) {}

	ID_META P2Meta::getID() const {
	return mMetaID;
	}

	#define P2_CLASS_TAG P2Img
	#define P2_TRACE TRACE_P2_IMG
	#include "P2_LogHeader.h"

	P2Img::P2Img(const ILog& log,
	const P2Pack& p2Pack,
	ID_IMG id,
	MUINT32 debugIndex)
	: mLog(log), mP2Pack(p2Pack), mImgID(id), mDebugIndex(debugIndex) {}

	ID_IMG P2Img::getID() const {
	return mImgID;
	}

	const char* P2Img::getHumanName() const {
	const char* name = getName(mImgID);
	if (mImgID == OUT_FD) {
	name = "fd";
	} else if (mImgID == OUT_YUV) {
	name = isDisplay() ? "display" : isRecord() ? "record" : "previewCB";
	}
	return name;
	}

	MSize P2Img::getImgSize() const {
	MSize size(0, 0);
	if (isValid()) {
	IImageBuffer* img = getIImageBufferPtr();
	if (img) {
	size = img->getImgSize();
	}
	}
	return size;
	}

	MSize P2Img::getTransformSize() const {
	MSize size(0, 0);
	if (isValid()) {
	IImageBuffer* img = getIImageBufferPtr();
	if (img) {
	size = img->getImgSize();
	if (getTransform() & eTransform_ROT_90) {
	size = MSize(size.h, size.w);
	}
	}
	}
	return size;
	}

	const char* P2Img::Fmt2Name(MINT fmt) {
	switch (fmt) {
	case NSCam::eImgFmt_RGBA8888:
	return "rgba";
	case NSCam::eImgFmt_RGB888:
	return "rgb";
	case NSCam::eImgFmt_RGB565:
	return "rgb565";
	case NSCam::eImgFmt_STA_BYTE:
	return "byte";
	case NSCam::eImgFmt_YVYU:
	return "yvyu";
	case NSCam::eImgFmt_UYVY:
	return "uyvy";
	case NSCam::eImgFmt_VYUY:
	return "vyuy";
	case NSCam::eImgFmt_YUY2:
	return "yuy2";
	case NSCam::eImgFmt_YV12:
	return "yv12";
	case NSCam::eImgFmt_YV16:
	return "yv16";
	case NSCam::eImgFmt_NV16:
	return "nv16";
	case NSCam::eImgFmt_NV61:
	return "nv61";
	case NSCam::eImgFmt_NV12:
	return "nv12";
	case NSCam::eImgFmt_NV21:
	return "nv21";
	case NSCam::eImgFmt_I420:
	return "i420";
	case NSCam::eImgFmt_I422:
	return "i422";
	case NSCam::eImgFmt_Y800:
	return "y800";
	case NSCam::eImgFmt_BAYER8:
	return "bayer8";
	case NSCam::eImgFmt_BAYER10:
	return "bayer10";
	case NSCam::eImgFmt_BAYER12:
	return "bayer12";
	case NSCam::eImgFmt_BAYER14:
	return "bayer14";
	case NSCam::eImgFmt_FG_BAYER8:
	return "fg_bayer8";
	case NSCam::eImgFmt_FG_BAYER10:
	return "fg_bayer10";
	case NSCam::eImgFmt_FG_BAYER12:
	return "fg_bayer12";
	case NSCam::eImgFmt_FG_BAYER14:
	return "fg_bayer14";
	default:
	return "unknown";
	}
	}

	MVOID P2Img::dumpBuffer() const {
	IImageBuffer* buffer = this->getIImageBufferPtr();
	if (buffer) {
	MUINT32 stride, pbpp, ibpp, width, height, size;
	MINT format = buffer->getImgFormat();
	stride = buffer->getBufStridesInBytes(0);
	pbpp = buffer->getPlaneBitsPerPixel(0);
	ibpp = buffer->getImgBitsPerPixel();
	size = buffer->getBufSizeInBytes(0);
	pbpp = pbpp ? pbpp : 8;
	width = stride * 8 / pbpp;
	width = width ? width : 1;
	ibpp = ibpp ? ibpp : 8;
	height = size / width;
	if (buffer->getPlaneCount() == 1) {
	height = height * 8 / ibpp;
	}

	char path[256];
	snprintf(path, sizeof(path), DUMP_PATH "/%04d_%02d_%s_%dx%d_%d.%s.bin",
	mLog.getLogFrameID(), mDebugIndex, getHumanName(), width, height,
	stride, Fmt2Name(format));
	buffer->saveToFile(path);
	}
	}

	MVOID P2Img::dumpNddBuffer() const {
	IImageBuffer* buffer = this->getIImageBufferPtr();
	if (buffer) {
	char filename[256] = {0};

	IMG_INFO info = getImgInfo(mImgID);

	FILE_DUMP_NAMING_HINT hint;
	hint = mP2Pack.getSensorData().mNDDHint;
	extract(&hint, buffer);

	switch (info.mirror) {
	case IN_FULL:
	genFileName_RAW(filename, sizeof(filename), &hint, RAW_PORT_IMGO);
	break;

	case IN_FULL_2:
	genFileName_RAW(filename, sizeof(filename), &hint, RAW_PORT_IMGO,
	info.name.c_str());
	break;

	case IN_RESIZED:
	genFileName_RAW(filename, sizeof(filename), &hint, RAW_PORT_RRZO);
	break;

	case IN_RESIZED_2:
	genFileName_RAW(filename, sizeof(filename), &hint, RAW_PORT_RRZO,
	info.name.c_str());
	break;

	case IN_LCSO:
	genFileName_LCSO(filename, sizeof(filename), &hint);
	break;

	case IN_LCSO_2:
	genFileName_LCSO(filename, sizeof(filename), &hint, info.name.c_str());
	break;

	case OUT_YUV: {
	if (this->isDisplay()) {
	genFileName_YUV(filename, sizeof(filename), &hint, YUV_PORT_WDMAO);
	} else if (this->isRecord()) {
	genFileName_YUV(filename, sizeof(filename), &hint, YUV_PORT_WROTO);
	} else {
	genFileName_YUV(filename, sizeof(filename), &hint,
	YUV_PORT_UNDEFINED);
	}
	} break;
	default:
	break;
	}

	if (filename[0]) {
	MY_S_LOGD(mP2Pack.mLog, "dump to: %s", filename);
	buffer->saveToFile(filename);
	}
	}
	}

	MINT32 P2Img::getMagic3A() const {
	return mP2Pack.getSensorData().mMagic3A;
	}

	MBOOL P2ImgPlugin::onPlugin(const std::shared_ptr<P2Img>& img) {
	return onPlugin(img.get());
	}

	MBOOL isValid(const P2Meta* meta) {
	return (meta != nullptr) && meta->isValid();
	}

	MBOOL isValid(const P2Img* img) {
	return (img != nullptr) && img->isValid();
	}

	MBOOL isValid(const std::shared_ptr<P2Meta>& meta) {
	return (meta != nullptr) && meta->isValid();
	}

	MBOOL isValid(const std::shared_ptr<P2Img>& img) {
	return (img != nullptr) && img->isValid();
	}

	IMetadata* toIMetadataPtr(const std::shared_ptr<P2Meta>& meta) {
	return meta != nullptr ? meta->getIMetadataPtr() : nullptr;
	}

	IImageBuffer* toIImageBufferPtr(const std::shared_ptr<P2Img>& img) {
	return img != nullptr ? img->getIImageBufferPtr() : nullptr;
	}

	} // namespace P2