/**************************************************************************\

							tB^[֐

  : 
    摜ϊtB^̃Cve[V

  o[W:

\**************************************************************************/

#include "stdafx.h"
#include "MonoSample.h"
#include "MAapi.h"

#include <stdio.h>

#define MODULE_NAME "gݍ݊֐"


/**************************************************************************\
                             MAuser_function()

@F
   MAuser_function֐́AMicroAVS̃j[ł̃vOC[hꂽ
   ɃR[܂BMicroAVSŕ\f[^̕ύXsɂ́Å֐
   MicroAVSAPIR[ĂB
\**************************************************************************/
int __stdcall MAuser_function()
{
	int ndim, ncomp;
	xp_long nnodes;
	int veclen;
	int result;

	// m[h擾
	result = MAget_nnodes(&nnodes);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAget_node_ncomp failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	// fBW̏擾
	result = MAget_ndim(&ndim);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAget_nnode failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	// z̃TCY擾
	xp_long points;
	result = MAget_npoints(&points);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAget_npoints failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	if(ndim != 2 && points != 2)
	{
		MessageBox(NULL, "摜f[^ł͂܂B", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}
	// m
	float* pPoints = (float*)MAalloc(MA_DTYPE_FLOAT, points);
	if(pPoints == NULL)
	{
		MessageBox(NULL, "Not enough memory.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	// Uniform^ARectilinear^̏ꍇ̍W̎擾
	xp_long size;
	result = MAget_points(&pPoints, &size);
	if(result == MAERROR)
	{
		MAfree(pPoints);
		MessageBox(NULL, "MAget_points failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	// Uniform^ARectilinear^̏ꍇ̍W̐ݒs
	result = MAset_points(pPoints, size);
	MAfree(pPoints);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAset_points failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	// W̎擾
	float* pCoordinates = (float*)MAalloc(MA_DTYPE_FLOAT, nnodes*ndim);
	if(pCoordinates == NULL)
	{
		MessageBox(NULL, "Not enough memory.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	result = MAget_coordinates(&pCoordinates, &size);
	if(result == MAERROR)
	{
		MAfree(pCoordinates);
		MessageBox(NULL, "MAget_coordinates failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	// W̐ݒ
	result = MAset_coordinates(pCoordinates, size);
	MAfree(pCoordinates);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAset_coordinates failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	// f[^̐ݒ肷
	result = MAget_node_ncomp(&ncomp);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAget_node_ncomp failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	// ŏ̃f[^ɕϊÃf[^͐ݒ肵Ȃ
	result = MAget_node_data_veclen(0, &veclen);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAget_node_veclen failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	xp_long data_size = nnodes*veclen;

	int dataType;
	result = MAget_data_type(0, &dataType);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAget_data_type failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}
	// 摜̃f[^i[郁m
	char* pValue = (char*)MAalloc(dataType, data_size);
	if(pValue == NULL)
	{
		MessageBox(NULL, "Out of memory.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	result = MAget_node_data(0, &pValue, &size, &dataType);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAget_node_data failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		MAfree(pValue);
		return 0;
	}

	// tB^[f[^i[郁̊m
	char* pnewValue = (char*)MAalloc(dataType, data_size);
	if(pnewValue == NULL)
	{
		MessageBox(NULL, "Out of memory.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	// 摜TCY̎擾
#ifdef WIN64
	xp_long* imageSize = (xp_long*)MAalloc(MA_DTYPE_LONG, 2);
#else
	xp_long* imageSize = (xp_long*)MAalloc(MA_DTYPE_INT, 2);
#endif
	if(imageSize == NULL)
	{
		MessageBox(NULL, "Out of memory.", MODULE_NAME, MB_OK|MB_ICONERROR);
		return 0;
	}

	int isize;
	result = MAget_dims(&imageSize, &isize);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAget_dims failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		MAfree(pValue);
		MAfree(pnewValue);
		MAfree(imageSize);
		return 0;
	}

	SIZE sz;
	sz.cx = (LONG)imageSize[0];
	sz.cy = (LONG)imageSize[1];

	result = MonoFilter(pValue, &pnewValue, sz);

	if(result == MAERROR)
	{
		MessageBox(NULL, "Internal function MonoFilter return error.", MODULE_NAME, MB_OK|MB_ICONERROR);
		MAfree(pValue);
		MAfree(pnewValue);
		MAfree(imageSize);
		return 0;
	}

	// nCpXtB^̏sꂽf[^ݒ肷
	result = MAset_node_data(0, (char*)pnewValue, data_size, dataType);
	if(result == MAERROR)
	{
		MessageBox(NULL, "MAset_node_data failed.", MODULE_NAME, MB_OK|MB_ICONERROR);
		MAfree(pValue);
		MAfree(pnewValue);
		MAfree(imageSize);
		return 0;
	}

	// J
	MAfree(pValue);
	MAfree(pnewValue);
	MAfree(imageSize);

	return 1;
}

/**************************************************************************\
                             MAuser_function_name()

@F
   MAuser_function_name֐́AMicroAVS̋NɁAvOC̃j[
   \镶ݒ肵܂B
\**************************************************************************/
void __stdcall MAuser_function_name(char* szFilterName)
{
	strcpy(szFilterName, "摜ϊtB^");
}

/**************************************************************************\
                             MonoFilter()

@F
   s֐
\**************************************************************************/
int MonoFilter(char const * const pSrc, char** ppDst, SIZE sz)
{
	char* pDst = *ppDst;
	const char* p;

	for(int raw = 0; raw < sz.cy; raw++)
	{
		p = pSrc + 4*sz.cx*raw;
		for(int col = 0; col < sz.cx; col++, pDst+=4, p+=4)
		{
			BYTE R, G, B;
			R = *(p+1);
			G = *(p+2);
			B = *(p+3);
			BYTE Mono = (BYTE)(R * 0.299 + G * 0.587 + B * 0.114);
			*pDst = *p; // Alpha
			*(pDst+1) = *(pDst+2) = *(pDst+3) = Mono;
		}
	}

	return MASUCCESS;
}