// Intrinsic.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <intrin.h>
#include <iostream>

#include <chrono>
using namespace std;

#include "ImageMapping.h"
using namespace ImageMapping;

void	Map16BitTo8Bit_u1(unsigned short *psh16BitData, long lDataLen, unsigned char* pby8BitData, int nBrightness, int nContrast);

int main()
{
	unsigned short* pSrc = new unsigned short[64 * 1280 * 1024];
	unsigned char* pDest = new unsigned char[64 * 1280 * 1024];

	/*
	_asm {
		push eax
		push ebx
		push ecx
		mov eax, 0x0F
		mov ebx, 0x10
		add eax, ebx
		mov ecx, pSrc
		mov[ecx], eax
		pop ecx
		pop ebx
		pop eax
	}
	*/

	for (int i = 0; i < 64 * 1280 * 1024; i++)
	{
		pSrc[i] = i % 65536;
	}

	int nHist[65536] = { 0 };
	memset(nHist, 0, sizeof(nHist));

	float fK = 0, fC = 0;
	LinarMapping::CalculateKC_u(fK, fC, pSrc, 1280 * 1024, 100, 100);

	for(int j = 0; j < 100; j++)
	{
		chrono::system_clock::time_point tm1 = chrono::system_clock::now();
		__int64 t1 = tm1.time_since_epoch().count();
				
		LinarMapping::Map16BitTo8Bit_u(pSrc, 1280*1024, pDest, fK, fC);

		//Map16BitTo8Bit_u1(pSrc, 1280 * 1024, pDest, 100, 100);

		chrono::system_clock::time_point tm2 = chrono::system_clock::now();
		__int64 t2 = tm2.time_since_epoch().count();

		int nTmSpan = (tm2 - tm1).count();

		int nTmSpan2 = t2 - t1;

		cout << "Index " << j << ": [Span] " << nTmSpan << " / " << nTmSpan2 << endl;
	}
	

	delete[] pSrc;
	pSrc = nullptr;

	delete[] pDest;
	pDest = nullptr;

	//getchar();

	return 0;
}

void	Map16BitTo8Bit_u1(unsigned short *psh16BitData, long lDataLen, unsigned char* pby8BitData, int nBrightness, int nContrast)
{
	if (psh16BitData == NULL || pby8BitData == NULL || lDataLen <= 0)
	{
		return;
	}

	//指向直方图的数据指针
	int pHist[65536] = { 0 };
	memset(pHist, 0, 65536 * sizeof(int));

	int i = 0;
	for (i = 0; i < lDataLen; i++)
	{
		pHist[psh16BitData[i]]++;
	}

	//设置阈值大小为: AreaSigma*图象大小/100
	int nSigma = 3 * 768;
	int nSum = 0;
	int nMin = 0;
	int nMax = 0;

	//求映射的最大最小值	
	for (i = 0; i < 65536; i++)
	{
		nSum += pHist[i];
		if (nSum >= nSigma)
		{
			nMin = i;
			break;
		}
	}

	nSum = 0;
	for (i = 65535; i >= 0; i--)
	{
		nSum += pHist[i];
		if (nSum >= nSigma)
		{
			nMax = i;
			break;
		}
	}

	nBrightness = (nBrightness > 100) ? 100 : nBrightness;
	nBrightness = (nBrightness < 0) ? 0 : nBrightness;

	nContrast = (nContrast > 100) ? 100 : nContrast;
	nContrast = (nContrast < 0) ? 0 : nContrast;

	//计算对比度亮度
	float K = (float)(256.0 / (nMax - nMin + 1)) * float(nBrightness / 100.0);
	float C = (float)(-K * nMin) * float(nContrast / 100.0);

	//图像映射
	for (i = 0; i < lDataLen; i++)
	{
		int nValue = (int)(K * psh16BitData[i] + C);
		if (nValue < 0)
		{
			pby8BitData[i] = 0;
		}
		else if (nValue > 255)
		{
			pby8BitData[i] = 255;
		}
		else
		{
			pby8BitData[i] = nValue;
		}
	}
}

/*
int main()
{
	__m128i varMi_0x00 = _mm_set_epi32(0x00, 0x00, 0x00, 0x00);
	__m128i varMi_0xFF = _mm_set_epi32(0xFF, 0xFF, 0xFF, 0xFF);
	
	__m128i varMi_Value = _mm_set_epi32(-5, 160, 128, 257);

	__m128i varMi_Mask_LT_0xFF = _mm_cmplt_epi32(varMi_Value, varMi_0xFF);
	__m128i varMi_Mask_GT_0x00 = _mm_cmpgt_epi32(varMi_Value, varMi_0x00);
	__m128i varMi_Mask_Normal = _mm_and_si128(varMi_Mask_LT_0xFF, varMi_Mask_GT_0x00);
	__m128i varMi_Value_Normal = _mm_and_si128(varMi_Value, varMi_Mask_Normal);

	__m128i varMi_Mask_0xFF = _mm_cmpgt_epi32(varMi_Value, varMi_0xFF);	
	__m128i varMi_0xFF_Valid = _mm_and_si128(varMi_0xFF, varMi_Mask_0xFF);

	varMi_Value = _mm_or_si128(varMi_Mask_Normal, varMi_0xFF_Valid);
	
	const int c_nMaxDataSize = 32 * 1024 * 1024;

	short* fArr_A = new short[c_nMaxDataSize];
	short* fArr_B = new short[c_nMaxDataSize];
	short* fArr_C = new short[c_nMaxDataSize];

	for (unsigned int i = 0; i < c_nMaxDataSize; i++)
	{
		fArr_A[i] = (i + 1) % 65536;
		fArr_B[i] = (i + 2) % 65536;
		fArr_C[i] = 0;
	}

	__m128 varM_a, varM_b, varM_c;
	__m128i varMi_a, varMi_b, varMi_c;

	bool bIntrinsic = true;

	short nArr[64] = { 0 };

	int nFlag = 1;

	for (int j = 0; j < 100; j++)
	{
		chrono::system_clock::time_point tm1 = chrono::system_clock::now();

		for (unsigned int i = 0; i < c_nMaxDataSize / 4; i++)
		{
			if (bIntrinsic)
			{
				varMi_a = _mm_set_epi32(fArr_A[i + 0], fArr_A[i + 1], fArr_A[i + 2], fArr_A[i + 3]);
				varM_a = _mm_cvtepi32_ps(varMi_a);

				varMi_b = _mm_set_epi32(fArr_B[i + 0], fArr_B[i + 1], fArr_B[i + 2], fArr_B[i + 3]);
				varM_b = _mm_cvtepi32_ps(varMi_b);

				varM_c = _mm_mul_ps(varM_a, varM_b);
				varM_c = _mm_mul_ps(varM_a, varM_b);
				varM_c = _mm_mul_ps(varM_a, varM_b);
				varM_c = _mm_mul_ps(varM_a, varM_b);

				__m128i varM_d = _mm_cvtps_epi32(varM_c);
				
				int* pAddr_Int = (int*)&varM_d;
								
				nArr[0] = pAddr_Int[0];//varM_d.m128i_i32[0];
				nArr[1] = pAddr_Int[1]; //varM_d.m128i_i32[1];
				nArr[2] = pAddr_Int[2]; //varM_d.m128i_i32[2];
				nArr[3] = pAddr_Int[3]; //varM_d.m128i_i32[3];
				
				//memcpy(nArr, pAddr_Int, 16);
				if(nFlag > 0)
				{
					memcpy(nArr, pAddr_Int, 16);
					nFlag = 1;
				}				
			}
			else
			{
				fArr_C[4 * i + 0] = fArr_A[4 * i + 0] * fArr_B[4 * i + 0];
				fArr_C[4 * i + 1] = fArr_A[4 * i + 1] * fArr_B[4 * i + 1];
				fArr_C[4 * i + 2] = fArr_A[4 * i + 2] * fArr_B[4 * i + 2];
				fArr_C[4 * i + 3] = fArr_A[4 * i + 3] * fArr_B[4 * i + 3];
				
				fArr_C[4 * i + 0] = fArr_A[4 * i + 0] * fArr_B[4 * i + 0];
				fArr_C[4 * i + 1] = fArr_A[4 * i + 1] * fArr_B[4 * i + 1];
				fArr_C[4 * i + 2] = fArr_A[4 * i + 2] * fArr_B[4 * i + 2];
				fArr_C[4 * i + 3] = fArr_A[4 * i + 3] * fArr_B[4 * i + 3];

				fArr_C[4 * i + 0] = fArr_A[4 * i + 0] * fArr_B[4 * i + 0];
				fArr_C[4 * i + 1] = fArr_A[4 * i + 1] * fArr_B[4 * i + 1];
				fArr_C[4 * i + 2] = fArr_A[4 * i + 2] * fArr_B[4 * i + 2];
				fArr_C[4 * i + 3] = fArr_A[4 * i + 3] * fArr_B[4 * i + 3];

				fArr_C[4 * i + 0] = fArr_A[4 * i + 0] * fArr_B[4 * i + 0];
				fArr_C[4 * i + 1] = fArr_A[4 * i + 1] * fArr_B[4 * i + 1];
				fArr_C[4 * i + 2] = fArr_A[4 * i + 2] * fArr_B[4 * i + 2];
				fArr_C[4 * i + 3] = fArr_A[4 * i + 3] * fArr_B[4 * i + 3];
			}
		}

		chrono::system_clock::time_point tm2 = chrono::system_clock::now();

		int nTmSpan = (tm2 - tm1).count();

		cout << "TmSpan " << j << ": " << nTmSpan << endl;
	}
	
	int jj = nArr[0];	

	return 0;
}
*/