Deliver/include/Img_header/FunctionDataTypeCommon.h

#pragma once
#include "PipelineDataCommon.h"
#include <string>
using namespace std;

enum FUNCTION_DATATYPE
{
	FUNCTION_DATATYPE_BASEMEMERY = 0,
	FUNCTION_DATATYPE_2D_GRAY_IMG,
	FUNCTION_DATATYPE_2D_RGB_IMG,

	FUNCTION_DATATYPE_INTLIST = 10000,
	FUNCTION_DATATYPE_POINTLIST,
	FUNCTION_DATATYPE_FLOATLIST,
	FUNCTION_DATATYPE_WCHARSTRING,


	FUNCTION_DATATYPE_END,
};

enum PIN_STATUS
{
	PIN_STATUS_IN,
	PIN_STATUS_OUT,
	PIN_STATUS_PARAM,
	PIN_STATUS_END,
};

enum MEM_STATUS
{
	MEM_NULL = 0,
	MEM_MEMORY = 1,
	MEM_GPU,
	MEM_SHAREMEMORY,
	MEM_END,
};

#define PIPELINE_DATATYPE FUNCTION_DATATYPE

#ifndef _PIPELINE_DATASTINFO
#define _PIPELINE_DATASTINFO

typedef struct  _MicroDisp
{
	wstring strMicroName;
	float fMinData;
	float fMaxData;
	unsigned int  nMaxLevel;

	_MicroDisp()
	{
		strMicroName = L"";
		fMinData = 0.0f;
		fMaxData = 0.0f;
		nMaxLevel = 0xffffffff;
	}

	_MicroDisp& operator= (const _MicroDisp& fh)
	{
		strMicroName = fh.strMicroName;
		fMinData = fh.fMinData;
		fMaxData = fh.fMaxData;
		nMaxLevel = fh.nMaxLevel;
		return *this;
	}
}
MICRO_DISP;

//PIPELINE_SKEY_FLOATLIST
typedef struct  _MemoryInfo
{
	unsigned int nElementSize;
	unsigned int nElementCount;
	_MemoryInfo()
	{
		memset(this, 0, sizeof(_MemoryInfo));
	}
	_MemoryInfo& operator=(const _MemoryInfo& fhd)
	{
		memcpy(this, &fhd, sizeof(_MemoryInfo));
		return *this;
	}
	_MemoryInfo& operator=(const PIPELINE_MEMORYINFO& fhd)
	{
		nElementSize = fhd.nElementSize;
		nElementCount = fhd.nElementCount;
		return *this;
	}
	void ConvertFrom(const PIPELINE_MEMORYINFO& fhd)
	{
		nElementSize = fhd.nElementSize;
		nElementCount = fhd.nElementCount;
	}
}
MEMORYINFO;


typedef struct  _FuncIODisp
{
	FUNCTION_DATATYPE eIOType;
	MEM_STATUS eMemStatus;

	_FuncIODisp()
	{
		eIOType = FUNCTION_DATATYPE_END;
		eMemStatus = MEM_MEMORY;
	}

	_FuncIODisp& operator= (const _FuncIODisp& fh)
	{
		eIOType = fh.eIOType;
		eMemStatus = fh.eMemStatus;
		return *this;
	}
}
FUNCIO_DISP;


//PIPELINE_SKEY_2D_GRAY
typedef struct  _Image2DGrayInfo
{
	unsigned int nWidth;
	unsigned int nHeight;
	unsigned int nBits;
	unsigned int nFrameId;

	_Image2DGrayInfo()
	{
		memset(this, 0, sizeof(_Image2DGrayInfo));
	}
	_Image2DGrayInfo& operator=(const _Image2DGrayInfo& fhd)
	{
		memcpy(this, &fhd, sizeof(_Image2DGrayInfo));
		return *this;
	}
	_Image2DGrayInfo& operator=(const PIPELINE_2DGRAYIMGINFO& fhd)
	{
		nWidth = fhd.nWidth;
		nHeight = fhd.nHeight;
		nBits = fhd.nBits;
		nFrameId = fhd.nFrameId;
		return *this;
	}
	void ConvertFrom(const PIPELINE_2DGRAYIMGINFO& fhd)
	{
		nWidth = fhd.nWidth;
		nHeight = fhd.nHeight;
		nBits = fhd.nBits;
		nFrameId = fhd.nFrameId;
	}
}
IMG2DGRAYINFO;

enum RGB_PLANARCONFIGURATION
{
	PLANAR_RGBRGB,
	PLANAR_BBGGRR,
	PLANAR_MEM_END,
};

//FUNCTION_DATATYPE_2D_RGB24_IMG
typedef struct  _Image2DRGBInfo
{
	unsigned int nWidth;
	unsigned int nHeight;
	unsigned int nBitsperSample;
	unsigned int nSamplesperPixel;
	unsigned int nFrameId;
	RGB_PLANARCONFIGURATION nPlanarConfiguration;

	_Image2DRGBInfo()
	{
		memset(this, 0, sizeof(_Image2DRGBInfo));
		nBitsperSample = 8;
	}
	_Image2DRGBInfo& operator=(const _Image2DRGBInfo& fhd)
	{
		memcpy(this, &fhd, sizeof(_Image2DRGBInfo));
		return *this;
	}
	_Image2DRGBInfo& operator=(const PIPELINE_2DRGBIMGINFO& fhd)
	{
		nWidth = fhd.nWidth;
		nHeight = fhd.nHeight;
		nBitsperSample = fhd.nBitsperSample;
		nSamplesperPixel = fhd.nSamplesperPixel;
		nPlanarConfiguration = (RGB_PLANARCONFIGURATION)fhd.nPlanarConfiguration;
		nFrameId = fhd.nFrameId;
		return *this;
	}
	void ConvertFrom(const PIPELINE_2DRGBIMGINFO& fhd)
	{
		nWidth = fhd.nWidth;
		nHeight = fhd.nHeight;
		nBitsperSample = fhd.nBitsperSample;
		nSamplesperPixel = fhd.nSamplesperPixel;
		nPlanarConfiguration = (RGB_PLANARCONFIGURATION)fhd.nPlanarConfiguration;
		nFrameId = fhd.nFrameId;
	}
}
IMG2DRGBINFO;

//PIPELINE_MKEY_LIST
typedef struct  _ListInfo
{
	unsigned int nCount;
	_ListInfo()
	{
		memset(this, 0, sizeof(_ListInfo));
	}
	_ListInfo& operator=(const _ListInfo& fhd)
	{
		memcpy(this, &fhd, sizeof(_ListInfo));
		return *this;
	}
	_ListInfo& operator=(const PIPELINE_FLOATLISTINFO& fhd)
	{
		nCount = fhd.nCount;
		return *this;
	}
}
LISTINFO;

#endif