8位、24位原圖數據（RAW）反像、水平鏡像、垂直鏡像算法實現 .

#define GFP_OPERATORIMAGEDATA_TYPE_INVERSE			1	// 反像圖像數據
#define GFP_OPERATORIMAGEDATA_TYPE_HMIRROR			2	// 水平鏡像圖像數據
#define GFP_OPERATORIMAGEDATA_TYPE_VMIRROR			3	// 垂直鏡像圖像數據

//24位
int OperatorImageDataEx(UCHAR* pImageData, int nw, int nh, int nBitCnt, UCHAR fOprType)
{
	if(nBitCnt == 8)
		return Gfp_OperatorImageData(pImageData, nw, nh, fOprType);

	if(nBitCnt != 24)
		return 0;

	UCHAR *pTmpData,  *pRowData, nSwap[3];
	int col, row, nMid, nrowLen, nOff;

	//	if(nBitCnt == 8)
	//		nrowLen = nw;
	//	else
	nrowLen = nw * 3;

	switch(fOprType)
	{
	case GFP_OPERATORIMAGEDATA_TYPE_INVERSE:
		pTmpData = pImageData;
		for(row = 0; row < nh; row++)
		{
			for(col = 0; col < nrowLen; col++, pTmpData++)
			{
				*pTmpData = ~(*pTmpData);
			}
		}
		return 1;

	case GFP_OPERATORIMAGEDATA_TYPE_HMIRROR:
		nMid = nw >> 1;
		pTmpData = pImageData;
		for(row = 0; row < nh; row++, pTmpData += nrowLen)
		{
			for(col = 0, nOff = 0; col < nMid; col++, nOff += 3)
			{
				memcpy(nSwap, pTmpData + nOff, 3);
				memcpy(pTmpData + nOff, pTmpData + (nw - 1 - col) * 3, 3);
				memcpy(pTmpData + (nw - 1 - col) * 3, nSwap, 3);
			}
		}
		return 1;

	case GFP_OPERATORIMAGEDATA_TYPE_VMIRROR:
		nMid = nh >> 1;
		pRowData = (UCHAR*)malloc(sizeof(UCHAR) *  nrowLen);
		if(NULL == pRowData)
			return 0;
		pTmpData = pImageData;
		for(row = 0; row < nMid; row++, pTmpData += nrowLen)
		{
			memcpy(pRowData, pTmpData, nrowLen);
			memcpy(pTmpData, pImageData + (nh - 1 - row) * nrowLen, nrowLen);
			memcpy(pImageData + (nh - 1 - row) * nrowLen, pRowData, nrowLen);
		}
		free(pRowData);
		pRowData = NULL;
		return 1;

	case GFP_OPERATORIMAGEDATA_TYPE_RU90IRROR:
		{
			unsigned char* pData = (unsigned char*)malloc(3*nh*nw);
			memset(pData, 0, 3*nw*nh);

			int nLineLen = 3*nw;

			int nlineLen1 = 3*nh;
						//memcpy(pData, pImageData, 3*nh*nw);
			for(int i = 0; i < nh; i++) 
			{
				for(int j = 0; j < nw; j++)
				{
					memcpy(pData + j* nlineLen1 + (nh - i - 1)* 3, /*j*nh + nh -1 -i ,*/ pImageData +i * nLineLen + j* 3, 3 );
					//*(pData + j * nh + nh - 1 - i) = *(pImageData + i * nw + j);
				}
			}
			memcpy(pImageData, pData, 3*nh*nw);
			free(pData);
			pData = NULL;
			return 1;
		}


	case GFP_OPERATORIMAGEDATA_TYPE_LD90IRROR:
		{
			unsigned char* pData1 = (unsigned char*)malloc(3*nh*nw);
			memset(pData1, 0, 3*nw*nh);
			int nWLenth = 3*nw;
			int nHLenth = 3*nh;

			for( int i = 0; i < nh; i++ )
			{
				for(int j =0; j < nw; j++ )
				{
					//memcpy(pData1+(nh-1-j)*nWLenth + i*3, pImageData+i*nWLenth+j*3, 3);
					memcpy(pData1 + (nw-1-j)*nHLenth + i*3, pImageData + i*nWLenth + j*3, 3);
				}
			}
			memcpy(pImageData,pData1,3*nw*nh);
			free(pData1);
			pData1 = NULL;
			return 1;
		}
	}

	return 0;
}

//8位
int OperatorImageData(UCHAR* pImageData, int nw, int nh, UCHAR fOprType)
{
	if(NULL == pImageData)
		return 0;

	UCHAR *pTmpData,  *pRowData, nSwap;
	int col, row, nMid;

	switch(fOprType)
	{
	case GFP_OPERATORIMAGEDATA_TYPE_INVERSE:
		pTmpData = pImageData;
		for(row = 0; row < nh; row++)
		{
			for(col = 0; col < nw; col++, pTmpData++)
			{
				*pTmpData = ~(*pTmpData);
			}
		}
		return 1;

	case GFP_OPERATORIMAGEDATA_TYPE_HMIRROR:
		nMid = nw >> 1;
		pTmpData = pImageData;
		for(row = 0; row < nh; row++, pTmpData += nw)
		{
			for(col = 0; col < nMid; col++)
			{
				nSwap = pTmpData[col];
				pTmpData[col] = pTmpData[nw - 1 - col];
				pTmpData[nw - 1 - col] = nSwap;
			}
		}
		return 1;

	case GFP_OPERATORIMAGEDATA_TYPE_VMIRROR:
		nMid = nh >> 1;
		pRowData = (UCHAR*)malloc(sizeof(UCHAR) *  nw);
		if(NULL == pRowData)
			return 0;
		pTmpData = pImageData;
		for(row = 0; row < nMid; row++, pTmpData += nw)
		{
			memcpy(pRowData, pTmpData, nw);
			memcpy(pTmpData, pImageData + (nh - 1 - row) * nw, nw);
			memcpy(pImageData + (nh - 1 - row) * nw, pRowData, nw);
		}
		free(pRowData);

		return 1;
	}

	return 0;
}