#if _MSC_VER >= 1400
#define _CRT_SECURE_NO_DEPRECATE 1
#endif

#include "tmachine.h"
#include "texception.h"
#include "tfilepath.h"
#include "tiio_png.h"
#include "tiio.h"
#include "../compatibility/tfile_io.h"

#define PNG_INTERNAL
#include "lpng124/png.h"

#include "tpixel.h"

// see http://www.libpng.org/pub/png/libpng-1.2.5-manual.html
using namespace std;
//------------------------------------------------------------

extern "C" {
void tnz_abort_handler(void)
{
	//throw "PNG error";
}

void tnz_error_fun(png_structp pngPtr, png_const_charp error_message)
{
	pngPtr->m_canDelete = 0;
	//throw error_message;
}
}

#if !defined(TNZ_LITTLE_ENDIAN)
TNZ_LITTLE_ENDIAN undefined !!
#endif

	//=========================================================

	inline USHORT
	mySwap(USHORT val)
{
#if TNZ_LITTLE_ENDIAN
	return ((val) | ((val & 0xff) << 8)); //((val>>8)|((val&0xff)<<8)); (vecchio codice)
#else
	return val;
#endif
}

//=========================================================

class PngReader : public Tiio::Reader
{
	FILE *m_chan;
	png_structp m_png_ptr;
	png_infop m_info_ptr, m_end_info_ptr;
	int m_bit_depth, m_color_type, m_interlace_type;
	int m_compression_type, m_filter_type;
	unsigned int m_sig_read;
	int m_y;
	bool m_is16bitEnabled;
	unsigned char *m_rowBuffer;
	unsigned char *m_tempBuffer; //Buffer temporaneo
public:
	PngReader()
		: m_chan(0), m_png_ptr(0), m_info_ptr(0), m_end_info_ptr(0), m_bit_depth(0), m_color_type(0), m_interlace_type(0), m_compression_type(0), m_filter_type(0), m_sig_read(0), m_y(0), m_is16bitEnabled(true), m_rowBuffer(0), m_tempBuffer(0)
	{
	}

	~PngReader()
	{
		if (m_png_ptr && m_png_ptr->m_canDelete == 1) //se la png e' corrotta, liberarla faceva crashare in release!
		{
			try {
				png_read_end(m_png_ptr, m_end_info_ptr);
			} catch (...) {
			}
			try {
				png_destroy_read_struct(&m_png_ptr, &m_info_ptr,
										&m_end_info_ptr);
			} catch (...) {
			}
		} //da quando leggiamo solo le info ho errori di tutti i tipi
		delete[] m_rowBuffer;
		delete[] m_tempBuffer;
	}

	virtual bool read16BitIsEnabled() const { return m_is16bitEnabled; }
	virtual void enable16BitRead(bool enabled) { m_is16bitEnabled = enabled; }

	void readLineInterlace(char *buffer) { readLineInterlace(buffer, 0, m_info.m_lx - 1, 1); }
	void readLineInterlace(short *buffer) { readLineInterlace(buffer, 0, m_info.m_lx - 1, 1); }

	void open(FILE *file)
	{
		try {
			m_chan = file;
		} catch (...) {
			perror("uffa");
			return;
		}

		unsigned char signature[8]; // da 1 a 8 bytes
		fread(signature, 1, sizeof signature, m_chan);
		bool isPng = !png_sig_cmp(signature, 0, sizeof signature);
		if (!isPng)
			return;

		m_png_ptr = png_create_read_struct(
			PNG_LIBPNG_VER_STRING, 0, tnz_error_fun, 0);
		if (!m_png_ptr)
			return;
		m_info_ptr = png_create_info_struct(m_png_ptr);
		if (!m_info_ptr) {
			png_destroy_read_struct(&m_png_ptr,
									(png_infopp)0, (png_infopp)0);
			return;
		}
		m_end_info_ptr = png_create_info_struct(m_png_ptr);
		if (!m_end_info_ptr) {
			png_destroy_read_struct(&m_png_ptr,
									&m_info_ptr, (png_infopp)0);
			return;
		}

		png_init_io(m_png_ptr, m_chan);

		png_set_sig_bytes(m_png_ptr, sizeof signature);

#if defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR)
		png_set_bgr(m_png_ptr);
		png_set_swap_alpha(m_png_ptr);
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
		png_set_bgr(m_png_ptr);
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB)
		png_set_swap_alpha(m_png_ptr);
#elif !defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
		@unknow channel order
#endif

		png_read_info(m_png_ptr, m_info_ptr);

		if (png_get_valid(m_png_ptr, m_info_ptr, PNG_INFO_pHYs)) {
			png_uint_32 xdpi = png_get_x_pixels_per_meter(m_png_ptr, m_info_ptr);
			png_uint_32 ydpi = png_get_y_pixels_per_meter(m_png_ptr, m_info_ptr);

			m_info.m_dpix = tround(xdpi * 0.0254);
			m_info.m_dpiy = tround(ydpi * 0.0254);
		}

		int rowBytes = png_get_rowbytes(m_png_ptr, m_info_ptr);

		if (m_rowBuffer)
			delete[] m_rowBuffer;
		//m_rowBuffer = new unsigned char[rowBytes];

		TUINT32 lx = 0, ly = 0;
		png_get_IHDR(m_png_ptr, m_info_ptr, &lx, &ly, &m_bit_depth, &m_color_type,
					 &m_interlace_type, &m_compression_type, &m_filter_type);
		m_info.m_lx = lx;
		m_info.m_ly = ly;

		m_info.m_bitsPerSample = m_bit_depth;

		int channels = png_get_channels(m_png_ptr, m_info_ptr);
		m_info.m_samplePerPixel = channels;

		if (channels == 1 || channels == 2) {
			if (m_bit_depth < 8) // (m_bit_depth == 1 || m_bit_depth == 2 || m_bit_depth == 4)
				m_rowBuffer = new unsigned char[lx * 3];
			else
				m_rowBuffer = new unsigned char[rowBytes * 4];
		} else {
			m_rowBuffer = new unsigned char[rowBytes];
		}

		//if (m_interlace_type==1)
		//    m_tempBuffer = new unsigned char[ly*rowBytes];

		/* if (m_interlace_type==1)
   {
	   if (channels==1 || channels==2)
	   {
		   if (m_bit_depth < 8)                          // (m_bit_depth == 1 || m_bit_depth == 2 || m_bit_depth == 4)
			   m_tempBuffer = new unsigned char[ly*lx*3];
		   else
			   m_tempBuffer = new unsigned char[ly*rowBytes*4];
       }
       else
       {
	       m_tempBuffer = new unsigned char[ly*rowBytes];
       }     
   }*/

		/*if (m_color_type == PNG_COLOR_TYPE_PALETTE)
	   {
      png_destroy_read_struct(&m_png_ptr,
           &m_info_ptr, (png_infopp)0);
      return;
     }*/

		if (m_color_type == PNG_COLOR_TYPE_PALETTE) {
			m_info.m_valid = true;
			png_set_palette_to_rgb(m_png_ptr);
		}

		if (m_color_type == PNG_COLOR_TYPE_GRAY &&
			m_bit_depth < 8)
			png_set_gray_1_2_4_to_8(m_png_ptr);

		if (png_get_valid(m_png_ptr, m_info_ptr,
						  PNG_INFO_tRNS))
			png_set_tRNS_to_alpha(m_png_ptr);

		if (m_bit_depth == 16 && !m_is16bitEnabled)
			png_set_strip_16(m_png_ptr);

#if defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
		if (m_color_type == PNG_COLOR_TYPE_RGB ||
			m_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
			png_set_bgr(m_png_ptr);
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR)
		if (m_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
			png_set_swap_alpha(m_png_ptr);
#elif !defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM) && !defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB)
		@unknow channel order
#endif

		if (m_color_type == PNG_COLOR_TYPE_GRAY ||
			m_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
			png_set_gray_to_rgb(m_png_ptr);
	}

	void readLine(char *buffer, int x0, int x1, int shrink)
	{
		int ly = m_info.m_ly;
		if (!m_tempBuffer) {
			int lx = m_info.m_lx;
			int channels = png_get_channels(m_png_ptr, m_info_ptr);
			int rowBytes = png_get_rowbytes(m_png_ptr, m_info_ptr);
			if (m_interlace_type == 1) {
				if (channels == 1 || channels == 2) {
					if (m_bit_depth < 8)
						m_tempBuffer = new unsigned char[ly * lx * 3];
					else
						m_tempBuffer = new unsigned char[ly * rowBytes * 4];
				} else {
					m_tempBuffer = new unsigned char[ly * rowBytes];
				}
			}
		}
		int lx = m_info.m_lx;

		if (m_interlace_type == 1 && lx > 4) {
			readLineInterlace(&buffer[0], x0, x1, shrink);
			m_y++;
			if (m_tempBuffer && m_y == ly) {
				delete[] m_tempBuffer;
				m_tempBuffer = 0;
			}
			return;
		}

		int y = m_info.m_ly - 1 - m_y;
		if (y < 0)
			return;
		m_y++;

		png_bytep row_pointer = m_rowBuffer;
		png_read_row(m_png_ptr, row_pointer, NULL);

		writeRow(buffer);

		if (m_tempBuffer && m_y == ly) {
			delete[] m_tempBuffer;
			m_tempBuffer = 0;
		}
	}

	void readLine(short *buffer, int x0, int x1, int shrink)
	{
		int ly = m_info.m_ly;
		if (!m_tempBuffer) {
			int lx = m_info.m_lx;
			int channels = png_get_channels(m_png_ptr, m_info_ptr);
			int rowBytes = png_get_rowbytes(m_png_ptr, m_info_ptr);
			if (m_interlace_type == 1) {
				if (channels == 1 || channels == 2) {
					if (m_bit_depth < 8) // (m_bit_depth == 1 || m_bit_depth == 2 || m_bit_depth == 4)
						m_tempBuffer = new unsigned char[ly * lx * 3];
					else
						m_tempBuffer = new unsigned char[ly * rowBytes * 4];
				} else {
					m_tempBuffer = new unsigned char[ly * rowBytes];
				}
			}
		}

		if (m_png_ptr->interlaced == 1) {
			readLineInterlace(&buffer[0], x0, x1, shrink);
			m_y++;
			if (m_tempBuffer && m_y == ly) {
				delete[] m_tempBuffer;
				m_tempBuffer = 0;
			}
			return;
		}

		int y = m_info.m_ly - 1 - m_y;
		if (y < 0)
			return;
		m_y++;

		png_bytep row_pointer = m_rowBuffer;
		png_read_row(m_png_ptr, row_pointer, NULL);

		writeRow(buffer);

		if (m_tempBuffer && m_y == ly) {
			delete[] m_tempBuffer;
			m_tempBuffer = 0;
		}
	}

	int skipLines(int lineCount)
	{
		for (int i = 0; i < lineCount; i++) {
			if (m_interlace_type == 1 && m_info.m_lx > 4) // pezza. Studiare il codice
			{
				int channels = png_get_channels(m_png_ptr, m_info_ptr);
				char *lineBuffer = (char *)malloc(4 * m_info.m_lx * sizeof(char));
				readLine(lineBuffer, 0, m_info.m_lx - 1, 1);
				free(lineBuffer);
			} else {
				m_y++;
				png_bytep row_pointer = m_rowBuffer;
				png_read_row(m_png_ptr, row_pointer, NULL);
			}
		}
		return lineCount;
	}

	Tiio::RowOrder getRowOrder() const
	{
		return Tiio::TOP2BOTTOM;
	}

	void writeRow(char *buffer)
	{
		if (m_color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
			m_color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
			if (m_bit_depth == 16) {
				TPixel32 *pix = (TPixel32 *)buffer;
				int i = -2;
				for (int j = 0; j < m_info.m_lx; j++) {
#if defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB)
					pix[j].m = m_rowBuffer[i = i + 2];
					pix[j].r = m_rowBuffer[i = i + 2];
					pix[j].g = m_rowBuffer[i = i + 2];
					pix[j].b = m_rowBuffer[i = i + 2];
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
					pix[j].r = m_rowBuffer[i = i + 2];
					pix[j].g = m_rowBuffer[i = i + 2];
					pix[j].b = m_rowBuffer[i = i + 2];
					pix[j].m = m_rowBuffer[i = i + 2];
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
					pix[j].b = m_rowBuffer[i = i + 2];
					pix[j].g = m_rowBuffer[i = i + 2];
					pix[j].r = m_rowBuffer[i = i + 2];
					pix[j].m = m_rowBuffer[i = i + 2];
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR)
					pix[j].m = m_rowBuffer[i = i + 2];
					pix[j].b = m_rowBuffer[i = i + 2];
					pix[j].g = m_rowBuffer[i = i + 2];
					pix[j].r = m_rowBuffer[i = i + 2];
#else
					@unknow channel order
#endif
				}
			} else {
				TPixel32 *pix = (TPixel32 *)buffer;
				int i = 0;
				for (int j = 0; j < m_info.m_lx; j++) {
#if defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB)
					pix[j].m = m_rowBuffer[i++];
					pix[j].r = m_rowBuffer[i++];
					pix[j].g = m_rowBuffer[i++];
					pix[j].b = m_rowBuffer[i++];
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
					pix[j].r = m_rowBuffer[i++];
					pix[j].g = m_rowBuffer[i++];
					pix[j].b = m_rowBuffer[i++];
					pix[j].m = m_rowBuffer[i++];
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
					pix[j].b = m_rowBuffer[i++];
					pix[j].g = m_rowBuffer[i++];
					pix[j].r = m_rowBuffer[i++];
					pix[j].m = m_rowBuffer[i++];
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR)
					pix[j].m = m_rowBuffer[i++];
					pix[j].b = m_rowBuffer[i++];
					pix[j].g = m_rowBuffer[i++];
					pix[j].r = m_rowBuffer[i++];
#else
					@unknow channel order
#endif
				}
			}
		} else //qui gestisce RGB senza alpha.
		{	  // grayscale e' gestito come RGB perche' si usa png_set_gray_to_rgb
			if (m_bit_depth == 16) {
				TPixel32 *pix = (TPixel32 *)buffer;
				int i = -2;
				for (int j = 0; j < m_info.m_lx; j++) {
#if defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB) || defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
					pix[j].r = m_rowBuffer[i = i + 2];
					pix[j].g = m_rowBuffer[i = i + 2];
					pix[j].b = m_rowBuffer[i = i + 2];
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR) || defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
					pix[j].b = m_rowBuffer[i = i + 2];
					pix[j].g = m_rowBuffer[i = i + 2];
					pix[j].r = m_rowBuffer[i = i + 2];
#else
					@unknow channel order
#endif
					pix[j].m = 255;
				}
			} else {
				TPixel32 *pix = (TPixel32 *)buffer;
				int i = 0;
				for (int j = 0; j < m_info.m_lx; j++) {
#if defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB) || defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
					pix[j].r = m_rowBuffer[i++];
					pix[j].g = m_rowBuffer[i++];
					pix[j].b = m_rowBuffer[i++];
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR) || defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
					pix[j].b = m_rowBuffer[i++];
					pix[j].g = m_rowBuffer[i++];
					pix[j].r = m_rowBuffer[i++];
#else
					@unknow channel order
#endif
					pix[j].m = 255;
				}
			}
		}
	}

	void writeRow(short *buffer)
	{
		if (m_color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
			m_color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
			TPixel64 *pix = (TPixel64 *)buffer;
			int i = -2; //0;
			for (int j = 0; j < m_info.m_lx; j++) {
#if defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB) || defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
				pix[j].r = mySwap(m_rowBuffer[i = i + 2]); //i++
				pix[j].g = mySwap(m_rowBuffer[i = i + 2]);
				pix[j].b = mySwap(m_rowBuffer[i = i + 2]);
				pix[j].m = mySwap(m_rowBuffer[i = i + 2]);
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR) || defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
				pix[j].b = mySwap(m_rowBuffer[i = i + 2]); //i++
				pix[j].g = mySwap(m_rowBuffer[i = i + 2]);
				pix[j].r = mySwap(m_rowBuffer[i = i + 2]);
				pix[j].m = mySwap(m_rowBuffer[i = i + 2]);
#else
				@unknow channel order
#endif
				//pix[j].m = 255;
			}
		} else //qui gestisce RGB senza alpha.
		{	  // grayscale e' gestito come RGB perche' si usa png_set_gray_to_rgb
			TPixel64 *pix = (TPixel64 *)buffer;
			int i = -2;
			for (int j = 0; j < m_info.m_lx; j++) {
#if defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB) || defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
				pix[j].r = mySwap(m_rowBuffer[i = i + 2]);
				pix[j].g = mySwap(m_rowBuffer[i = i + 2]);
				pix[j].b = mySwap(m_rowBuffer[i = i + 2]);
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR) || defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
				pix[j].b = mySwap(m_rowBuffer[i = i + 2]);
				pix[j].g = mySwap(m_rowBuffer[i = i + 2]);
				pix[j].r = mySwap(m_rowBuffer[i = i + 2]);
#else
				@unknow channel order
#endif
				pix[j].m = mySwap(255);
			}
		}
	}

	void copyPixel(int count, int dstX, int dstDx, int dstY)
	{

		int channels = png_get_channels(m_png_ptr, m_info_ptr);
		int rowBytes = png_get_rowbytes(m_png_ptr, m_info_ptr);
		int lx = m_info.m_lx;

		if ((channels == 4 || channels == 3) && m_bit_depth == 16) {
			for (int i = 0; i < count; i += 2) {
				for (int j = 0; j < channels * 2; j++) {
					(m_tempBuffer + (dstY * rowBytes))[(i * dstDx + dstX) * channels + j] = m_rowBuffer[i * channels + j];
				}
			}
		} else if (channels == 2 && m_bit_depth == 16) {
			for (int i = 0; i < count; i += 2) {
				for (int j = 0; j < 4 * 2; j++) {
					(m_tempBuffer + (dstY * rowBytes * 4))[(i * dstDx + dstX) * 4 + j] = m_rowBuffer[i * 4 + j];
				}
			}
		} else if (channels == 1 && m_bit_depth == 16) {
			for (int i = 0; i < count; i += 2) {
				for (int j = 0; j < 3 * 2; j++) {
					(m_tempBuffer + (dstY * rowBytes * 4))[(i * dstDx + dstX) * 3 + j] = m_rowBuffer[i * 3 + j];
				}
			}
		} else if (channels == 1 && m_bit_depth == 8) {
			for (int i = 0; i < count; i++) {
				for (int j = 0; j < 3; j++) {
					(m_tempBuffer + (dstY * rowBytes * 4))[(i * dstDx + dstX) * 3 + j] = m_rowBuffer[i * 3 + j];
				}
			}
		} else if (channels == 2 && m_bit_depth == 8) {
			for (int i = 0; i < count; i++) {
				for (int j = 0; j < 4; j++) {
					(m_tempBuffer + (dstY * rowBytes * 4))[(i * dstDx + dstX) * 4 + j] = m_rowBuffer[i * 4 + j];
				}
			}
		} else if ((channels == 1 || channels == 2) && m_bit_depth < 8) {
			for (int i = 0; i < count; i++) {
				for (int j = 0; j < 3; j++) {
					(m_tempBuffer + (dstY * lx * 3))[(i * dstDx + dstX) * 3 + j] = m_rowBuffer[i * 3 + j];
				}
			}
		} else {
			for (int i = 0; i < count; i++) {
				for (int j = 0; j < channels; j++) {
					(m_tempBuffer + (dstY * rowBytes))[(i * dstDx + dstX) * channels + j] = m_rowBuffer[i * channels + j];
				}
			}
		}
	}

	void readLineInterlace(char *buffer, int x0, int x1, int shrink)
	{

		//m_png_ptr->row_number è l'indice di riga che scorre quando chiamo la png_read_row
		int rowNumber = m_png_ptr->row_number;
		//numRows è il numero di righe processate in ogni passo
		int numRows = (m_png_ptr->height) / 8;

		int passPng = m_png_ptr->pass; //conosco il passo d'interlacciamento

		int passRow = 5 + (m_y & 1); //passo desiderato per la riga corrente

		int channels = png_get_channels(m_png_ptr, m_info_ptr);

		int rowBytes = png_get_rowbytes(m_png_ptr, m_info_ptr);
		png_bytep row_pointer = m_rowBuffer;

		int lx = m_info.m_lx;

		while (passPng <= passRow && rowNumber <= numRows) //finchè il passo d'interlacciamento è minore o uguale
														   // <             //del passo desiderato effettua tante volte le lettura della riga
														   //quant'è il passo desiderato per quella riga
		{
			rowNumber = m_png_ptr->row_number;
			png_read_row(m_png_ptr, row_pointer, NULL);
			numRows = m_png_ptr->num_rows;
			//devo memorizzare la riga letta nel buffer di appoggio in base al passo di riga
			//e al blocchetto di appartenenza della riga

			//copio i pixel che desidero nel buffer temporaneo

			//il membro di PngReader copyPixel deve tener conto della riga processata
			//e del passo che si è effettuato ( e in base a quello so quanti pixel copiare!)

			if (m_bit_depth == 16) {
				if (passPng == 0)
					copyPixel(lx / 4, 0, 8, rowNumber * 8);
				else if (passPng == 1)
					copyPixel(lx / 4, 8, 8, rowNumber * 8);
				else if (passPng == 2)
					copyPixel(lx / 2, 0, 4, rowNumber * 8 + 4);
				else if (passPng == 3)
					copyPixel(lx / 2, 4, 4, rowNumber * 4);
				else if (passPng == 4)
					copyPixel(lx, 0, 2, rowNumber * 4 + 2);
				else if (passPng == 5)
					copyPixel(lx, 2, 2, rowNumber * 2);
				else if (passPng == 6)
					copyPixel(2 * lx, 0, 1, rowNumber * 2 + 1);
			} else {
				if (passPng == 0)
					copyPixel((lx + 7) / 8, 0, 8, rowNumber * 8);
				else if (passPng == 1)
					copyPixel((lx + 3) / 8, 4, 8, rowNumber * 8);
				else if (passPng == 2)
					copyPixel((lx + 3) / 4, 0, 4, rowNumber * 8 + 4);
				else if (passPng == 3)
					copyPixel((lx + 1) / 4, 2, 4, rowNumber * 4);
				else if (passPng == 4)
					copyPixel((lx + 1) / 2, 0, 2, rowNumber * 4 + 2);
				else if (passPng == 5)
					copyPixel(lx / 2, 1, 2, rowNumber * 2);
				else if (passPng == 6)
					copyPixel(lx, 0, 1, rowNumber * 2 + 1);
			}

			passPng = m_png_ptr->pass;
		}

		// fase di copia
		if (channels == 1 || channels == 2) {
			if (m_bit_depth < 8)
				memcpy(m_rowBuffer, m_tempBuffer + ((m_y)*lx * 3), lx * 3);
			else
				memcpy(m_rowBuffer, m_tempBuffer + ((m_y)*rowBytes * 4), rowBytes * 4);
		} else {
			memcpy(m_rowBuffer, m_tempBuffer + ((m_y)*rowBytes), rowBytes);
		}

		// fase di copia vecchia
		//memcpy(m_rowBuffer, m_tempBuffer+((m_y)*rowBytes), rowBytes);

		//tutto quello che segue lo metto in una funzione in cui scrivo il buffer di restituzione della readLine
		//è una funzione comune alle ReadLine
		writeRow(buffer);
	}

	void readLineInterlace(short *buffer, int x0, int x1, int shrink)
	{

		//m_png_ptr->row_number è l'indice di riga che scorre quando chiamo la png_read_row
		int rowNumber = m_png_ptr->row_number;
		//numRows è il numero di righe processate in ogni passo
		int numRows = (m_png_ptr->height) / 8;

		int passPng = m_png_ptr->pass; //conosco il passo d'interlacciamento

		int passRow = 5 + (m_y & 1); //passo desiderato per la riga corrente

		int channels = png_get_channels(m_png_ptr, m_info_ptr);
		int lx = m_info.m_lx;

		int rowBytes = png_get_rowbytes(m_png_ptr, m_info_ptr);
		png_bytep row_pointer = m_rowBuffer;

		while (passPng <= passRow && rowNumber < numRows) //finchè il passo d'interlacciamento è minore o uguale
														  //del passo desiderato effettua tante volte le lettura della riga
														  //quant'è il passo desiderato per quella riga
		{
			rowNumber = m_png_ptr->row_number;
			png_read_row(m_png_ptr, row_pointer, NULL);
			numRows = m_png_ptr->num_rows;
			int lx = m_info.m_lx;

			//devo memorizzare la riga letta nel buffer di appoggio in base al passo di riga
			//e al blocchetto di appartenenza della riga

			//copio i pixel che desidero nel buffer temporaneo

			//il membro di PngReader copyPixel deve tener conto della riga processata
			//e del passo che si è effettuato ( e in base a quello so quanti pixel copiare!)

			int channels = png_get_channels(m_png_ptr, m_info_ptr);

			if (passPng == 0)
				copyPixel(lx / 4, 0, 8, rowNumber * 8);
			else if (passPng == 1)
				copyPixel(lx / 4, 8, 8, rowNumber * 8);
			else if (passPng == 2)
				copyPixel(lx / 2, 0, 4, rowNumber * 8 + 4);
			else if (passPng == 3)
				copyPixel(lx / 2, 4, 4, rowNumber * 4);
			else if (passPng == 4)
				copyPixel(lx, 0, 2, rowNumber * 4 + 2);
			else if (passPng == 5)
				copyPixel(lx, 2, 2, rowNumber * 2);
			else if (passPng == 6)
				copyPixel(2 * lx, 0, 1, rowNumber * 2 + 1);

			passPng = m_png_ptr->pass;
		}

		// fase di copia
		if (channels == 1 || channels == 2) {
			memcpy(m_rowBuffer, m_tempBuffer + ((m_y)*rowBytes * 4), rowBytes * 4);
		} else {
			memcpy(m_rowBuffer, m_tempBuffer + ((m_y)*rowBytes), rowBytes);
		}

		// fase di copia
		//memcpy(m_rowBuffer, m_tempBuffer+((m_y)*rowBytes), rowBytes);

		//tutto quello che segue lo metto in una funzione in cui scrivo il buffer di restituzione della readLine
		//è una funzione comune alle ReadLine
		writeRow(buffer);
	}
};

//=========================================================

Tiio::PngWriterProperties::PngWriterProperties()
	: m_matte("Alpha Channel", true)

{
	bind(m_matte);
}

//=========================================================

class PngWriter : public Tiio::Writer
{
	png_structp m_png_ptr;
	png_infop m_info_ptr;
	FILE *m_chan;
	bool m_matte;
	vector<TPixel> *m_colormap;

public:
	PngWriter();
	~PngWriter();

	void open(FILE *file, const TImageInfo &info);
	void writeLine(char *buffer);
	virtual void writeLine(short *buffer);

	Tiio::RowOrder getRowOrder() const
	{
		return Tiio::TOP2BOTTOM;
	}

	void flush();
	virtual bool write64bitSupported() const { return true; }
};

//---------------------------------------------------------

PngWriter::PngWriter()
	: m_png_ptr(0), m_info_ptr(0), m_matte(true), m_colormap(0)
{
}

//---------------------------------------------------------

PngWriter::~PngWriter()
{
	if (m_png_ptr) {
		png_destroy_write_struct(
			&m_png_ptr,
			&m_info_ptr);
	}
	if (m_chan) {
		fflush(m_chan);
		m_chan = 0;
	}
}

//---------------------------------------------------------

png_color palette[256];
png_byte alpha[1];

void PngWriter::open(FILE *file, const TImageInfo &info)
{
	m_info = info;
	m_png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
										(png_voidp)0, //user_error_ptr,
										0,			  //user_error_fn,
										0);			  //user_warning_fn);
	if (!m_png_ptr)
		return;
	m_info_ptr = png_create_info_struct(m_png_ptr);
	if (!m_info_ptr) {
		png_destroy_write_struct(&m_png_ptr, (png_infopp)0);
		return;
	}

	m_chan = file;
	png_init_io(m_png_ptr, m_chan);

	if (!m_properties)
		m_properties = new Tiio::PngWriterProperties();

	TBoolProperty *alphaProp = (TBoolProperty *)(m_properties->getProperty("Alpha Channel"));
	TPointerProperty *colormap = (TPointerProperty *)(m_properties->getProperty("Colormap"));
	m_matte = (alphaProp && alphaProp->getValue()) ? true : false;
	if (colormap)
		m_colormap = (vector<TPixel> *)colormap->getValue();

	TUINT32 x_pixels_per_meter = tround(m_info.m_dpix / 0.0254);
	TUINT32 y_pixels_per_meter = tround(m_info.m_dpiy / 0.0254);

	if (!m_colormap)
		png_set_IHDR(m_png_ptr, m_info_ptr,
					 m_info.m_lx, m_info.m_ly,
					 info.m_bitsPerSample, m_matte ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB,
					 PNG_INTERLACE_NONE,
					 PNG_COMPRESSION_TYPE_DEFAULT,
					 PNG_FILTER_TYPE_DEFAULT);
	else {
		png_set_IHDR(m_png_ptr, m_info_ptr,
					 m_info.m_lx, m_info.m_ly,
					 8, PNG_COLOR_TYPE_PALETTE,
					 PNG_INTERLACE_NONE,
					 PNG_COMPRESSION_TYPE_DEFAULT,
					 PNG_FILTER_TYPE_DEFAULT);
		for (unsigned int i = 0; i < m_colormap->size(); i++) {
			/*unsigned char red = (i>>5)&0x7;
			unsigned char green = (i>>2)&0x7;
			unsigned char blue = i&0x3;
			palette[i].red = (red>>1) | (red<<2) | (red<<5);
			palette[i].green = (green>>1) | (green<<2) | (green<<5);
			palette[i].blue = blue | (blue<<2) | (blue<<4) | (blue<<6);
			if (red==0 && green==0) alpha[i] = 0; else if (blue==0 && green==0) alpha[i] = 128; else alpha[i] = 255;*/
			palette[i].red = (*m_colormap)[i].r;
			palette[i].green = (*m_colormap)[i].g;
			palette[i].blue = (*m_colormap)[i].b;
		}

		png_set_PLTE(m_png_ptr, m_info_ptr, palette, m_colormap->size());
	}

//png_set_dither(m_png_ptr, palette, 256, 256, 0, 1);

#if defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR)
	png_set_bgr(m_png_ptr);
	png_set_swap_alpha(m_png_ptr);
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
	png_set_bgr(m_png_ptr);
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB)
	png_set_swap_alpha(m_png_ptr);
#elif !defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
	@unknow channel order
#endif

	png_write_info(m_png_ptr, m_info_ptr);
	png_write_pHYs(m_png_ptr, x_pixels_per_meter, y_pixels_per_meter, 1);

	if (m_colormap && m_matte) {
		alpha[0] = 0;
		png_write_tRNS(m_png_ptr, alpha, 0, 1, PNG_COLOR_TYPE_PALETTE);
	}
}

//---------------------------------------------------------

void PngWriter::flush()
{
	png_write_end(m_png_ptr, m_info_ptr);
	fflush(m_chan);
}

//---------------------------------------------------------

void PngWriter::writeLine(short *buffer)
{

	{
		TPixel64 *pix = (TPixel64 *)buffer;
		unsigned short *tmp;
		tmp = (unsigned short *)malloc((m_info.m_lx + 1) * 3);
		//unsigned short tmp[10000];
		int k = 0;
		for (int j = 0; j < m_info.m_lx; j++) {
#if defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB) || defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
			tmp[k++] = mySwap(pix->r);
			tmp[k++] = mySwap(pix->g);
			tmp[k++] = mySwap(pix->b);
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR) || defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
			tmp[k++] = mySwap(pix->b);
			tmp[k++] = mySwap(pix->g);
			tmp[k++] = mySwap(pix->r);
#else
			@unknow channel order
#endif
			if (m_matte)
				tmp[k++] = mySwap(pix->m);
			++pix;
		}
		png_write_row(m_png_ptr, (unsigned char *)tmp);
	}
}

//=========================================================

void PngWriter::writeLine(char *buffer)
{
	//TBoolProperty* alphaProp = (TBoolProperty*)(m_properties->getProperty("Alpha Channel"));
	if (m_matte || m_colormap) {
		png_bytep row_pointer = (unsigned char *)buffer;
		png_write_row(m_png_ptr, row_pointer);
	} else {
		unsigned char *tmp = 0;
		TPixel32 *pix = (TPixel32 *)buffer;
		tmp = (unsigned char *)malloc((m_info.m_lx + 1) * 3);

		//     unsigned char tmp[10000];
		int k = 0;
		for (int j = 0; j < m_info.m_lx; j++) {

//tmp = (pix->r&0xe0)|((pix->g&0xe0)>>3) | ((pix->b&0xc0)>>6);

#if defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB) || defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
			tmp[k++] = pix->r;
			tmp[k++] = pix->g;
			tmp[k++] = pix->b;
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR) || defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
			tmp[k++] = pix->b;
			tmp[k++] = pix->g;
			tmp[k++] = pix->r;
#else
			@unknow channel order
#endif

			++pix;
		}
		png_write_row(m_png_ptr, tmp);
	}
}

//=========================================================

Tiio::Reader *Tiio::makePngReader()
{
	return new PngReader();
}

Tiio::Writer *Tiio::makePngWriter()
{
	return new PngWriter();
}