Blob Blame Raw
#if _MSC_VER >= 1400
#define _CRT_SECURE_NO_DEPRECATE 1
#endif
#define IS_TIFF_MAIN

#if _WIN32
#include <io.h>
#else
#include <unistd.h>
#endif

#include <memory>

#include "tiio.h"
#include "tpixel.h"
#include "tsystem.h"
#include "../tzp/toonztags.h"
#include "tconvert.h"
#include "tpixelutils.h"
#include "traster.h"

extern "C" {
#include "tiffio.h"
}

#include "tiio_tif.h"

#ifdef _WIN32
#pragma warning(disable : 4996)
#include "windows.h"
#endif

//**************************************************************************
//    TifReader  implementation
//**************************************************************************

class TifReader : public Tiio::Reader
{
	TIFF *m_tiff;
	int m_row;
	bool m_tiled, m_stripped;
	int m_rowsPerStrip;
	int m_stripIndex;
	int m_rowLength;
	UCHAR *m_stripBuffer;
	double m_xdpi, m_ydpi;
	Tiio::RowOrder m_rowOrder;
	bool is16bitEnabled;
	bool m_isTzi;
	TRasterGR8P m_tmpRas;

public:
	TifReader(bool isTzi);
	~TifReader();

	void open(FILE *file);

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

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

	int skipLines(int lineCount);
	void readLine(char *buffer, int x0, int x1, int shrink);
	void readLine(short *buffer, int x0, int x1, int shrink);
};

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

TifReader::TifReader(bool isTzi)
	: m_tiff(0), m_row(0), m_rowsPerStrip(0), m_stripIndex(-1)
	  //, m_stripBuffer(0)
	  ,
	  m_rowLength(0), m_xdpi(0), m_ydpi(0), m_rowOrder(Tiio::TOP2BOTTOM), is16bitEnabled(true), m_isTzi(isTzi), m_tmpRas(0)
{
	TIFFSetWarningHandler(0);
}

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

TifReader::~TifReader()
{
	if (m_tiff)
		TIFFClose(m_tiff);

	if (m_tmpRas)
		m_tmpRas->unlock();

	delete m_info.m_properties;
}

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

void TifReader::open(FILE *file)
{
	int fd = fileno(file);
#if 0
	m_tiff = TIFFFdOpenNoCloseProc(fd, "", "rb");
#else
	m_tiff = TIFFFdOpen(dup(fd), "", "rb");
#endif
	if (!m_tiff) {
		std::string str("Tiff file closed");
		throw(str);
	}

	uint32 w = 0, h = 0, rps = 0;
	uint16 bps = 0, spp = 0;
	uint32 tileWidth = 0, tileLength = 0;

	//TIFFSetDirectory(m_tiff,1);
	//TIFFGetField(m_tiff, TIFFTAG_PAGENUMBER, &pn);
	//int pn = TIFFNumberOfDirectories(m_tiff);
	//TIFFSetDirectory(m_tiff,1);
	TIFFGetField(m_tiff, TIFFTAG_IMAGEWIDTH, &w);
	TIFFGetField(m_tiff, TIFFTAG_IMAGELENGTH, &h);
	TIFFGetField(m_tiff, TIFFTAG_BITSPERSAMPLE, &bps);
	TIFFGetField(m_tiff, TIFFTAG_SAMPLESPERPIXEL, &spp);
	TIFFGetField(m_tiff, TIFFTAG_ROWSPERSTRIP, &rps);
	//int stripCount = TIFFNumberOfStrips(m_tiff);
	//int tileCount = TIFFNumberOfTiles(m_tiff);
	TIFFGetField(m_tiff, TIFFTAG_TILEWIDTH, &tileWidth);
	TIFFGetField(m_tiff, TIFFTAG_TILELENGTH, &tileLength);
	Tiio::TifWriterProperties *prop = new Tiio::TifWriterProperties();
	m_info.m_properties = prop;
	uint16 orient = Tiio::TOP2BOTTOM;
	if (TIFFGetField(m_tiff, TIFFTAG_ORIENTATION, &orient)) {
		switch (orient) {
		case ORIENTATION_TOPLEFT: /* row 0 top, col 0 lhs */
			prop->m_orientation.setValue(TNZ_INFO_ORIENT_TOPLEFT);
			m_rowOrder = Tiio::TOP2BOTTOM;
			break;
		case ORIENTATION_TOPRIGHT: /* row 0 top, col 0 rhs */
			prop->m_orientation.setValue(TNZ_INFO_ORIENT_TOPRIGHT);
			m_rowOrder = Tiio::TOP2BOTTOM;
			break;
		case ORIENTATION_LEFTTOP: /* row 0 lhs, col 0 top */
			prop->m_orientation.setValue(TNZ_INFO_ORIENT_LEFTTOP);
			m_rowOrder = Tiio::TOP2BOTTOM;
			break;
		case ORIENTATION_RIGHTTOP: /* row 0 rhs, col 0 top */
			prop->m_orientation.setValue(TNZ_INFO_ORIENT_RIGHTTOP);
			m_rowOrder = Tiio::TOP2BOTTOM;
			break;

		case ORIENTATION_BOTRIGHT: /* row 0 bottom, col 0 rhs */
			prop->m_orientation.setValue(TNZ_INFO_ORIENT_BOTRIGHT);
			m_rowOrder = Tiio::BOTTOM2TOP;
			break;
		case ORIENTATION_BOTLEFT: /* row 0 bottom, col 0 lhs */
			prop->m_orientation.setValue(TNZ_INFO_ORIENT_BOTLEFT);
			m_rowOrder = Tiio::BOTTOM2TOP;
			break;
		case ORIENTATION_RIGHTBOT: /* row 0 rhs, col 0 bottom */
			prop->m_orientation.setValue(TNZ_INFO_ORIENT_RIGHTBOT);
			m_rowOrder = Tiio::BOTTOM2TOP;
			break;
		case ORIENTATION_LEFTBOT: /* row 0 lhs, col 0 bottom */
			prop->m_orientation.setValue(TNZ_INFO_ORIENT_LEFTBOT);
			m_rowOrder = Tiio::BOTTOM2TOP;
			break;
		default:
			prop->m_orientation.setValue(TNZ_INFO_ORIENT_NONE);
			m_rowOrder = Tiio::TOP2BOTTOM;
			break;
		}
	}

	USHORT compression;
	TIFFGetField(m_tiff, TIFFTAG_COMPRESSION, &compression);
	switch (compression) {
	case COMPRESSION_LZW:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_LZW);
		break;
	case COMPRESSION_PACKBITS:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_PACKBITS);
		break;
	case COMPRESSION_THUNDERSCAN:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_THUNDERSCAN);
		break;
	case COMPRESSION_CCITTFAX3:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_CCITTFAX3);
		break;
	case COMPRESSION_CCITTFAX4:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_CCITTFAX4);
		break;
	case COMPRESSION_CCITTRLE:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_CCITTRLE);
		break;
	case COMPRESSION_JPEG:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_JPEG);
		break;
	case COMPRESSION_OJPEG:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_OJPEG);
		break;
	case COMPRESSION_NONE:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_NONE);
		break;
	case COMPRESSION_SGILOG:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_SGILOG);
		break;
	case COMPRESSION_SGILOG24:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_SGILOG24);
		break;
	case COMPRESSION_ADOBE_DEFLATE:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_ADOBE_DEFLATE);
		break;
	case COMPRESSION_DEFLATE:
		prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_DEFLATE);
		break;
	/*default :
      prop->m_compressionType.setValue(TNZ_INFO_COMPRESS_UNKNOWN);
      break;*/
	default:
		assert(0);
	}

	float xdpi = 0, ydpi = 0;
	TIFFGetField(m_tiff, TIFFTAG_XRESOLUTION, &xdpi);
	TIFFGetField(m_tiff, TIFFTAG_YRESOLUTION, &ydpi);

	bool swapxy = false; // orient == ORIENTATION_RIGHTTOP;

	if (swapxy) {
		tswap(w, h);
		tswap(xdpi, ydpi);
	}

	m_xdpi = xdpi;
	m_ydpi = ydpi;
	m_info.m_lx = w;
	m_info.m_ly = h;
	m_info.m_dpix = xdpi;
	m_info.m_dpiy = ydpi;

	m_info.m_samplePerPixel = spp;

	if (bps == 64 && spp == 3)
		bps = 16; //immagine con bpp = 192

	uint16 photometric; //codice di controllo
	TIFFGetField(m_tiff, TIFFTAG_PHOTOMETRIC, &photometric);
	if (photometric == 3 && (bps == 2 || bps == 4)) //immagini con PHOTOMATRIC_PALETTE
		bps = 8;

	if (photometric == 1 && (bps == 12 || bps == 24))
		bps = 16;

	if (bps == 6)
		bps = 4; //immagini con bps = 6

	if (bps == 10 || bps == 12 || bps == 14) //immagini con bps = 10 , 12 , 14 , 24 , 32
		bps = 8;
	if (bps == 24 || bps == 32)
		bps = 16;

	m_info.m_bitsPerSample = bps;

	if (bps == 8)
		switch (spp) {
		case 1: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L" 8(GREYTONES)");
			break;
		case 3: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"24(RGB)");
			break;
		case 4: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"32(RGBM)");
			break;
		}
	else if (bps == 16)
		switch (spp) {
		case 1: /* row 0 top, col 0 lhs */
			//prop->m_bitsPerPixel.setValue(L"16(GREYTONES)");
			break;
		case 3: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"48(RGB)");
			break;
		case 4: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"64(RGBM)");
			break;
		}

	else if (bps == 2)
		switch (spp) {
		case 1: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"32(RGBM)");
			break;
		case 3: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"32(RGBM)");
			break;
		case 4: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"32(RGBM)");
			break;
		}

	else if (bps == 1)
		switch (spp) {
		case 1: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L" 1(BW)");
			break;
		case 3: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"32(RGBM)");
			break;
		case 4: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"32(RGBM)");
			break;
		}

	else if (bps == 4)
		switch (spp) {
		case 1: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L" 8(GREYTONES)");
			break;
		case 3: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"32(RGBM)");
			break;
		case 4: /* row 0 top, col 0 lhs */
			prop->m_bitsPerPixel.setValue(L"32(RGBM)");
			break;
		}

	else if (bps == 64 && spp == 3)
		prop->m_bitsPerPixel.setValue(L"64(RGBM)");

	else
		assert(false);

	if (TIFFIsTiled(m_tiff)) {
		m_rowsPerStrip = tileLength;
		int tilesPerRow = (w + tileWidth - 1) / tileWidth;
		//m_rowLength = tileWidth * tilesPerRow;
		m_rowLength = m_info.m_lx;
		int pixelSize = bps == 16 ? 8 : 4;
		int stripSize = m_rowsPerStrip * m_rowLength * pixelSize;

		m_tmpRas = TRasterGR8P(stripSize, 1);
		m_tmpRas->lock();

		m_stripBuffer = m_tmpRas->getRawData();
	} else {
		m_rowsPerStrip = rps;
		//if(m_rowsPerStrip<=0) m_rowsPerStrip = 1;			//potrei mettere qualsiasi valore
		//purchè sia lo stesso in tif_getimage.c linea 2512
		//if(m_rowsPerStrip==-1) assert(0);

		if (m_rowsPerStrip <= 0)
			m_rowsPerStrip = m_info.m_ly;

		int stripSize = m_rowsPerStrip * w * 4; // + 4096;  TIFFStripSize(m_tiff);

		if (bps == 16)
			stripSize *= 2;

		m_tmpRas = TRasterGR8P(stripSize, 1);
		m_tmpRas->lock();

		m_stripBuffer = m_tmpRas->getRawData();

		m_rowLength = m_info.m_lx; //w;
	}

	/* 
  int TIFFTileRowSize(m_tiff);

  m_rowsPerStrip = 0;
  if(TIFFGetField(m_tiff, TIFFTAG_ROWSPERSTRIP, &rps) )
    {
     int stripSize = TIFFStripSize(m_tiff);
     if(stripSize>0)
       {
       }
    }
    */
	if (m_isTzi) {
		USHORT risCount = 0;
		USHORT *risArray = 0;

		if (TIFFGetField(m_tiff, TIFFTAG_TOONZWINDOW, &risCount, &risArray)) {
			if (m_info.m_lx == risArray[2] && m_info.m_ly == risArray[3]) //se sono diverse, la lettura tif crasha....
			{
				//m_info.m_lx = risArray[2];
				//m_info.m_ly = risArray[3];
				m_info.m_x0 = risArray[0];
				m_info.m_y0 = risArray[1];
			}
			//      USHORT extraMask = risArray[4];
			//bool isEduFile = risArray[TOONZWINDOW_COUNT - 1] & 1;
		} else {
			m_info.m_x0 = 0;
			m_info.m_y0 = 0;
		}
		if (swapxy) {
			tswap(m_info.m_x0, m_info.m_y0);
			tswap(m_info.m_lx, m_info.m_ly);
		}
		m_info.m_x1 = m_info.m_x0 + w;
		m_info.m_y1 = m_info.m_y0 + h;
	} else {
		m_info.m_x0 = m_info.m_y0 = 0;
		m_info.m_x1 = m_info.m_x0 + m_info.m_lx - 1;
		m_info.m_y1 = m_info.m_y0 + m_info.m_ly - 1;
	}
}

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

int TifReader::skipLines(int lineCount)
{
	m_row += lineCount;
	return lineCount;
}

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

#include "timage_io.h"

void TifReader::readLine(short *buffer, int x0, int x1, int shrink)
{
	assert(shrink > 0);

	const int pixelSize = 8;
	int stripRowSize = m_rowLength * pixelSize;

	if (m_row < m_info.m_y0 || m_row > m_info.m_y1) {
		memset(buffer, 0, (x1 - x0 + 1) * pixelSize);
		m_row++;
		return;
	}

	int stripIndex = m_row / m_rowsPerStrip;
	if (m_stripIndex != stripIndex) {
		// Retrieve the strip holding current row. Please, observe that
		// TIFF functions will return the strip buffer in the BOTTOM-UP orientation,
		// no matter the internal tif's orientation storage

		m_stripIndex = stripIndex;

		if (TIFFIsTiled(m_tiff)) {
			// Retrieve tiles size
			uint32 tileWidth = 0, tileHeight = 0;
			TIFFGetField(m_tiff, TIFFTAG_TILEWIDTH, &tileWidth);
			TIFFGetField(m_tiff, TIFFTAG_TILELENGTH, &tileHeight);
			assert(tileWidth > 0 && tileHeight > 0);

			// Allocate a sufficient buffer to store a single tile
			int tileSize = tileWidth * tileHeight;
			std::unique_ptr<uint64[]> tile(new uint64[tileSize]);

			int x = 0;
			int y = tileHeight * m_stripIndex;

			// In case it's the last tiles row, the tile size might exceed the image bounds
			int lastTy = std::min((int)tileHeight, m_info.m_ly - y);

			// Traverse the tiles row
			while (x < m_info.m_lx) {
				int ret = TIFFReadRGBATile_64(m_tiff, x, y, tile.get());
				assert(ret);

				int tileRowSize = std::min((int)tileWidth, m_info.m_lx - x) * pixelSize;

				// Copy the tile rows in the corresponding output strip rows
				for (int ty = 0; ty < lastTy; ++ty) {
					memcpy(
						m_stripBuffer + (ty * m_rowLength + x) * pixelSize,
						(UCHAR *)tile.get() + ty * tileWidth * pixelSize,
						tileRowSize);
				}

				x += tileWidth;
			}
		} else {
			int y = m_rowsPerStrip * m_stripIndex;
			int ok = TIFFReadRGBAStrip_64(m_tiff, y, (uint64 *)m_stripBuffer);
			assert(ok);
		}
	}

	uint16 orient = ORIENTATION_TOPLEFT;
	TIFFGetField(m_tiff, TIFFTAG_ORIENTATION, &orient);

	int r = m_rowsPerStrip - 1 - (m_row % m_rowsPerStrip);
	switch (orient) // Pretty weak check for top/bottom orientation
	{
	case ORIENTATION_TOPLEFT:
	case ORIENTATION_TOPRIGHT:
	case ORIENTATION_LEFTTOP:
	case ORIENTATION_RIGHTTOP:
		// We have to invert the fixed BOTTOM-UP returned by TIFF functions - since this function is
		// supposed to ignore orientation issues (which are managed outside).

		// The last tiles row will actually start at the END OF THE IMAGE (not necessarily at
		// m_rowsPerStrip multiples). So, we must adjust for that.

		r = std::min(m_rowsPerStrip, m_info.m_ly - m_rowsPerStrip * m_stripIndex) - 1 -
			(m_row % m_rowsPerStrip);
		break;

	case ORIENTATION_BOTRIGHT:
	case ORIENTATION_BOTLEFT:
	case ORIENTATION_RIGHTBOT:
	case ORIENTATION_LEFTBOT:
		r = m_row % m_rowsPerStrip;
		break;
	}

	// Finally, copy the strip row to the output row buffer
	TPixel64 *pix = (TPixel64 *)buffer;
	USHORT *v = (USHORT *)(m_stripBuffer + r * stripRowSize);

	pix += x0;
	v += 4 * x0;

	int width = (x1 < x0) ? (m_info.m_lx - 1) / shrink + 1 : (x1 - x0) / shrink + 1;

	for (int i = 0; i < width; i++) {
		USHORT c = *v++;
		pix->r = c;
		c = *v++;
		pix->g = c;
		c = *v++;
		pix->b = c;
		c = *v++;
		pix->m = c;

		pix += shrink;
		v += 4 * (shrink - 1);
	}

	m_row++;
}

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

void TifReader::readLine(char *buffer, int x0, int x1, int shrink)
{
	if (this->m_info.m_bitsPerSample == 16 && this->m_info.m_samplePerPixel >= 3) {
		std::vector<short> app(4 * (m_info.m_lx));
		readLine(&app[0], x0, x1, shrink);

		TPixel64 *pixin = (TPixel64 *)&app[0];

		TPixel32 *pixout = (TPixel32 *)buffer;
		for (int j = 0; j < x0; j++) {
			pixout++;
			pixin++;
		}

		for (int i = 0; i < (x1 - x0) + 1; i++)
			*pixout++ = PixelConverter<TPixel32>::from(*pixin++);

		return;
	}

	assert(shrink > 0);

	const int pixelSize = 4;
	int stripRowSize = m_rowLength * pixelSize;

	if (m_row < m_info.m_y0 || m_row > m_info.m_y1) {
		memset(buffer, 0, (x1 - x0 + 1) * pixelSize);
		m_row++;
		return;
	}

	int stripIndex = m_row / m_rowsPerStrip;
	if (m_stripIndex != stripIndex) {
		m_stripIndex = stripIndex;

		if (TIFFIsTiled(m_tiff)) {
			uint32 tileWidth = 0, tileHeight = 0;
			TIFFGetField(m_tiff, TIFFTAG_TILEWIDTH, &tileWidth);
			TIFFGetField(m_tiff, TIFFTAG_TILELENGTH, &tileHeight);
			assert(tileWidth > 0 && tileHeight > 0);

			int tileSize = tileWidth * tileHeight;
			std::unique_ptr<uint32[]> tile(new uint32[tileSize]);

			int x = 0;
			int y = tileHeight * m_stripIndex;

			int lastTy = std::min((int)tileHeight, m_info.m_ly - y);

			while (x < m_info.m_lx) {
				int ret = TIFFReadRGBATile(m_tiff, x, y, tile.get());
				assert(ret);

				int tileRowSize = std::min((int)tileWidth, (int)(m_info.m_lx - x)) * pixelSize;

				for (int ty = 0; ty < lastTy; ++ty) {
					memcpy(
						m_stripBuffer + (ty * m_rowLength + x) * pixelSize,
						(UCHAR *)tile.get() + ty * tileWidth * pixelSize,
						tileRowSize);
				}

				x += tileWidth;
			}
		} else {
			int y = m_rowsPerStrip * m_stripIndex;
			int ok = TIFFReadRGBAStrip(m_tiff, y, (uint32 *)m_stripBuffer);
			assert(ok);
		}
	}

	uint16 orient = ORIENTATION_TOPLEFT;
	TIFFGetField(m_tiff, TIFFTAG_ORIENTATION, &orient);

	int r = m_rowsPerStrip - 1 - (m_row % m_rowsPerStrip);
	switch (orient) // Pretty weak check for top/bottom orientation
	{
	case ORIENTATION_TOPLEFT:
	case ORIENTATION_TOPRIGHT:
	case ORIENTATION_LEFTTOP:
	case ORIENTATION_RIGHTTOP:
		// We have to invert the fixed BOTTOM-UP returned by TIFF functions - since this function is
		// supposed to ignore orientation issues (which are managed outside).

		// The last tiles row will actually start at the END OF THE IMAGE (not necessarily at
		// m_rowsPerStrip multiples). So, we must adjust for that.

		r = std::min(m_rowsPerStrip, m_info.m_ly - m_rowsPerStrip * m_stripIndex) - 1 -
			(m_row % m_rowsPerStrip);
		break;

	case ORIENTATION_BOTRIGHT:
	case ORIENTATION_BOTLEFT:
	case ORIENTATION_RIGHTBOT:
	case ORIENTATION_LEFTBOT:
		r = m_row % m_rowsPerStrip;
		break;
	}

	TPixel32 *pix = (TPixel32 *)buffer;
	uint32 *v = (uint32 *)(m_stripBuffer + r * stripRowSize);

	pix += x0;
	v += x0;

	int width = (x1 < x0) ? (m_info.m_lx - 1) / shrink + 1 : (x1 - x0) / shrink + 1;

	for (int i = 0; i < width; i++) {
		uint32 c = *v;
		pix->r = (UCHAR)TIFFGetR(c);
		pix->g = (UCHAR)TIFFGetG(c);
		pix->b = (UCHAR)TIFFGetB(c);
		pix->m = (UCHAR)TIFFGetA(c);

		v += shrink;
		pix += shrink;
	}

	m_row++;
}

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

Tiio::TifWriterProperties::TifWriterProperties()
	: m_byteOrdering("Byte Ordering"), m_compressionType("Compression Type"), m_bitsPerPixel("Bits Per Pixel"), m_orientation("Orientation")
{
	m_byteOrdering.addValue(L"IBM PC");
	m_byteOrdering.addValue(L"Mac");
#ifdef _WIN32
	m_byteOrdering.setValue(L"IBM PC");
#else
	m_byteOrdering.setValue(L"Mac");
#endif
	m_compressionType.addValue(TNZ_INFO_COMPRESS_LZW);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_NONE);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_PACKBITS);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_THUNDERSCAN);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_CCITTFAX3);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_CCITTFAX4);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_CCITTRLE);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_JPEG);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_OJPEG);

	m_compressionType.addValue(TNZ_INFO_COMPRESS_SGILOG);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_SGILOG24);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_ADOBE_DEFLATE);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_DEFLATE);
	m_compressionType.addValue(TNZ_INFO_COMPRESS_UNKNOWN);

	m_compressionType.setValue(TNZ_INFO_COMPRESS_LZW);

	m_bitsPerPixel.addValue(L"24(RGB)");
	m_bitsPerPixel.addValue(L"48(RGB)");
	m_bitsPerPixel.addValue(L" 1(BW)");		   // WATCH OUT! If you reorder this remember to look for
	m_bitsPerPixel.addValue(L" 8(GREYTONES)"); // TRasterImage::isScanBW() usage that bpp choice index
	//m_bitsPerPixel.addValue(L"16(GREYTONES)");                  // is HARDCODED nearby...                   -.-'
	m_bitsPerPixel.addValue(L"32(RGBM)");
	m_bitsPerPixel.addValue(L"64(RGBM)");

	m_bitsPerPixel.setValue(L"32(RGBM)");

	m_orientation.addValue(TNZ_INFO_ORIENT_TOPLEFT);
	m_orientation.addValue(TNZ_INFO_ORIENT_TOPRIGHT);
	m_orientation.addValue(TNZ_INFO_ORIENT_BOTRIGHT);
	m_orientation.addValue(TNZ_INFO_ORIENT_BOTLEFT);
	m_orientation.addValue(TNZ_INFO_ORIENT_LEFTTOP);
	m_orientation.addValue(TNZ_INFO_ORIENT_RIGHTTOP);
	m_orientation.addValue(TNZ_INFO_ORIENT_RIGHTBOT);
	m_orientation.addValue(TNZ_INFO_ORIENT_LEFTBOT);

	//m_orientation.setValue(TNZ_INFO_ORIENT_TOPLEFT);

	bind(m_byteOrdering);
	bind(m_compressionType);
	bind(m_bitsPerPixel);
	bind(m_orientation);
}

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

class TifWriter : public Tiio::Writer
{

	TIFF *m_tiff;
	int m_row;
	//Tiio::TifWriterProperties m_properties;
	unsigned char *m_lineBuffer;
	Tiio::RowOrder m_rowOrder;
	int m_bpp;
	int m_RightToLeft;
	void fillBits(UCHAR *bufout, UCHAR *bufin, int lx, int incr);

public:
	TifWriter();
	~TifWriter();

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

	void flush();

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

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

TifWriter::TifWriter()
	: m_tiff(0), m_row(-1), m_lineBuffer(0), m_RightToLeft(false)
{
	TIFFSetWarningHandler(0);
}

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

TifWriter::~TifWriter()
{
	if (m_tiff)
		TIFFClose(m_tiff);

	delete m_lineBuffer;
	delete m_properties;
}

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

void TifWriter::open(FILE *file, const TImageInfo &info)
{
	m_info = info;
	std::string mode = "w";

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

	std::wstring byteOrdering = ((TEnumProperty *)(m_properties->getProperty("Byte Ordering")))->getValue();
	if (byteOrdering == L"IBM PC")
		mode += "l";
	else
		mode += "b";

	TEnumProperty *p = (TEnumProperty *)(m_properties->getProperty("Bits Per Pixel"));
	assert(p);
	std::string str = toString(p->getValue());
	//const char* str = toString(p->getValue()).c_str();
	m_bpp = atoi(str.c_str());
	assert(m_bpp == 1 || m_bpp == 8 || m_bpp == 16 || m_bpp == 24 || m_bpp == 32 || m_bpp == 48 || m_bpp == 64);

	int fd = fileno(file);
#if 0
	m_tiff = TIFFFdOpenNoCloseProc(fd, "", mode.c_str());
#else
	m_tiff = TIFFFdOpen(dup(fd), "", mode.c_str());
#endif
	if (!m_tiff)
		return;

	std::wstring worientation = ((TEnumProperty *)(m_properties->getProperty("Orientation")))->getValue();

	int orientation;
	if (worientation == TNZ_INFO_ORIENT_TOPLEFT)
		orientation = ORIENTATION_TOPLEFT;
	else if (worientation == TNZ_INFO_ORIENT_TOPRIGHT)
		orientation = ORIENTATION_TOPRIGHT;
	else if (worientation == TNZ_INFO_ORIENT_BOTRIGHT)
		orientation = ORIENTATION_BOTRIGHT;
	else if (worientation == TNZ_INFO_ORIENT_BOTLEFT)
		orientation = ORIENTATION_BOTLEFT;
	else if (worientation == TNZ_INFO_ORIENT_LEFTTOP)
		orientation = ORIENTATION_LEFTTOP;
	else if (worientation == TNZ_INFO_ORIENT_RIGHTTOP)
		orientation = ORIENTATION_RIGHTTOP;
	else if (worientation == TNZ_INFO_ORIENT_RIGHTBOT)
		orientation = ORIENTATION_RIGHTBOT;
	else if (worientation == TNZ_INFO_ORIENT_LEFTBOT)
		orientation = ORIENTATION_LEFTBOT;
	else
		assert(0);

	switch (orientation) {
	case ORIENTATION_TOPLEFT: /* row 0 top, col 0 lhs */
		m_rowOrder = Tiio::TOP2BOTTOM;
		break;
	case ORIENTATION_TOPRIGHT: /* row 0 top, col 0 rhs */
		m_rowOrder = Tiio::TOP2BOTTOM;
		break;
	case ORIENTATION_LEFTTOP: /* row 0 lhs, col 0 top */
		m_rowOrder = Tiio::TOP2BOTTOM;
		break;
	case ORIENTATION_RIGHTTOP: /* row 0 rhs, col 0 top */
		m_rowOrder = Tiio::TOP2BOTTOM;
		break;

	case ORIENTATION_BOTRIGHT: /* row 0 bottom, col 0 rhs */
		m_rowOrder = Tiio::BOTTOM2TOP;
		break;
	case ORIENTATION_BOTLEFT: /* row 0 bottom, col 0 lhs */
		m_rowOrder = Tiio::BOTTOM2TOP;
		break;
	case ORIENTATION_RIGHTBOT: /* row 0 rhs, col 0 bottom */
		m_rowOrder = Tiio::BOTTOM2TOP;
		break;
	case ORIENTATION_LEFTBOT: /* row 0 lhs, col 0 bottom */
		m_rowOrder = Tiio::BOTTOM2TOP;
		break;
	default:
		m_rowOrder = Tiio::TOP2BOTTOM;
		break;
	}
	m_RightToLeft = false;
	if (orientation == ORIENTATION_TOPRIGHT || orientation == ORIENTATION_BOTRIGHT ||
		orientation == ORIENTATION_RIGHTTOP || orientation == ORIENTATION_RIGHTBOT)
		m_RightToLeft = true;

	int bitsPerSample = (m_bpp == 1) ? 1 : ((m_bpp == 8 || m_bpp == 24 || m_bpp == 32) ? 8 : 16);

	TIFFSetField(m_tiff, TIFFTAG_IMAGEWIDTH, m_info.m_lx);
	TIFFSetField(m_tiff, TIFFTAG_IMAGELENGTH, m_info.m_ly);
	TIFFSetField(m_tiff, TIFFTAG_BITSPERSAMPLE, bitsPerSample);
	TIFFSetField(m_tiff, TIFFTAG_SAMPLESPERPIXEL, m_bpp / bitsPerSample);
	TIFFSetField(m_tiff, TIFFTAG_ORIENTATION, orientation);

	if (m_bpp == 1)
		TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4);
	else {
		std::wstring compressionType = ((TEnumProperty *)(m_properties->getProperty("Compression Type")))->getValue();
		if (compressionType == TNZ_INFO_COMPRESS_LZW)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
		else if (compressionType == TNZ_INFO_COMPRESS_PACKBITS)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS);
		else if (compressionType == TNZ_INFO_COMPRESS_CCITTFAX3)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX3);
		else if (compressionType == TNZ_INFO_COMPRESS_CCITTFAX4)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4);
		else if (compressionType == TNZ_INFO_COMPRESS_CCITTRLE)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_CCITTRLE);
		else if (compressionType == TNZ_INFO_COMPRESS_JPEG)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_JPEG);
		else if (compressionType == TNZ_INFO_COMPRESS_OJPEG)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_OJPEG);
		else if (compressionType == TNZ_INFO_COMPRESS_NONE)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
		else if (compressionType == TNZ_INFO_COMPRESS_THUNDERSCAN)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_THUNDERSCAN);
		else if (compressionType == TNZ_INFO_COMPRESS_ADOBE_DEFLATE)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_ADOBE_DEFLATE);
		else if (compressionType == TNZ_INFO_COMPRESS_DEFLATE)
			TIFFSetField(m_tiff, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
		else
			assert(false);
	}
	TIFFSetField(m_tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
	TIFFSetField(m_tiff, TIFFTAG_PHOTOMETRIC, (m_bpp == 8 || m_bpp == 1) ? PHOTOMETRIC_MINISBLACK : PHOTOMETRIC_RGB);
	TIFFSetField(m_tiff, TIFFTAG_XRESOLUTION, m_info.m_dpix);
	TIFFSetField(m_tiff, TIFFTAG_YRESOLUTION, m_info.m_dpiy);
	TIFFSetField(m_tiff, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
	TIFFSetField(m_tiff, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(m_tiff, 0));

	m_row = 0;
	if (m_bpp == 1)
		m_lineBuffer = new unsigned char[m_info.m_lx / 8 + 1];
	else
		m_lineBuffer = new unsigned char[(m_bpp == 1 ? 1 : m_bpp / 8) * m_info.m_lx];
}

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

void TifWriter::flush()
{
	TIFFFlush(m_tiff);
}

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

void TifWriter::writeLine(short *buffer)
{
	int delta = 1;
	int start = 0;
	if (m_RightToLeft) {
		delta = -1;
		start = m_info.m_lx - 1;
	}
	if (m_bpp == 16) {
		unsigned short *pix = ((unsigned short *)buffer) + start;
		for (int i = 0; i < m_info.m_lx; i++) {
			unsigned short *b = (unsigned short *)m_lineBuffer + i * 2;
			b[0] = pix[0];
			b[1] = pix[1];
			pix = pix + delta;
		}
	} else {
		assert(m_bpp == 48 || m_bpp == 64);
		TPixel64 *pix = ((TPixel64 *)buffer) + start;

		if (m_bpp == 64)
			for (int i = 0; i < m_info.m_lx; i++) {
				unsigned short *b = (unsigned short *)m_lineBuffer + i * 4;
				b[0] = pix->r;
				b[1] = pix->g;
				b[2] = pix->b;
				b[3] = pix->m;
				pix = pix + delta;
			}
		else if (m_bpp == 48)
			for (int i = 0; i < m_info.m_lx; i++) {
				unsigned short *b = (unsigned short *)m_lineBuffer + i * 3;
				b[0] = pix->r;
				b[1] = pix->g;
				b[2] = pix->b;
				pix = pix + delta;
			}
	}
	TIFFWriteScanline(m_tiff, m_lineBuffer, m_row++, 0);
}

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

void TifWriter::fillBits(UCHAR *bufout, UCHAR *bufin, int lx, int incr)
{
	int lx1 = lx / 8 + ((lx % 8) ? 1 : 0);

	for (int i = 0; i < lx1; i++, bufout++) {
		UCHAR pix = 0xff;
		for (int j = 0; j < 8; j++, bufin += incr)
			if (*bufin < m_bwThreshold)
				pix &= ~(0x1 << (7 - j));
		*bufout = pix;
	}
}

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

void TifWriter::writeLine(char *buffer)
{
	int delta = 1;
	int start = 0;
	if (m_RightToLeft) {
		delta = -1;
		start = m_info.m_lx - 1;
	}
	if (m_bpp == 1)
		fillBits(m_lineBuffer, ((unsigned char *)buffer) + start, m_info.m_lx, delta);
	else if (m_bpp == 8) {
		unsigned char *pix = ((unsigned char *)buffer) + start;
		for (int i = 0; i < m_info.m_lx; i++) {
			unsigned char *b = m_lineBuffer + i;
			b[0] = pix[0];
			pix = pix + delta;
		}
	} else {
		assert(m_bpp == 24 || m_bpp == 32);
		TPixel32 *pix = ((TPixel32 *)buffer) + start;

		if (m_bpp == 32)
			for (int i = 0; i < m_info.m_lx; i++) {
				unsigned char *b = m_lineBuffer + i * 4;
				b[0] = pix->r;
				b[1] = pix->g;
				b[2] = pix->b;
				b[3] = pix->m;
				pix = pix + delta;
			}
		else if (m_bpp == 24)
			for (int i = 0; i < m_info.m_lx; i++) {
				unsigned char *b = m_lineBuffer + i * 3;
				b[0] = pix->r;
				b[1] = pix->g;
				b[2] = pix->b;
				pix = pix + delta;
			}
	}
	TIFFWriteScanline(m_tiff, m_lineBuffer, m_row++, 0);
}

//============================================================
#ifdef _DEBUG
/* Error & Waring Handler per debug */

extern "C" {
static void
MyWarningHandler(const char *module, const char *fmt, va_list ap)
{
	std::string outMsg;
	char msg[2048];
	msg[0] = 0;
	if (module != NULL)
		outMsg = std::string(module);
	outMsg += "Warning, ";

	_vsnprintf(msg, 2048, fmt, ap);
	strcat(msg, ".\n");

	outMsg += msg;
	TSystem::outputDebug(outMsg);
}

static void
MyErrorHandler(const char *module, const char *fmt, va_list ap)
{
	std::string outMsg;
	char msg[2048];
	msg[0] = 0;
	if (module != NULL)
		outMsg = std::string(module);
	//outMsg += "Warning, ";

	_vsnprintf(msg, 2048, fmt, ap);
	strcat(msg, ".\n");

	outMsg += msg;
	TSystem::outputDebug(outMsg);
}
}

#endif

Tiio::Reader *Tiio::makeTifReader()
{
#ifdef _DEBUG
	TIFFSetErrorHandler(MyErrorHandler);
	TIFFSetWarningHandler(MyWarningHandler);
#endif
	return new TifReader(false);
}

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

Tiio::Reader *Tiio::makeTziReader()
{
#ifdef _DEBUG
	TIFFSetErrorHandler(MyErrorHandler);
	TIFFSetWarningHandler(MyWarningHandler);
#endif
	return new TifReader(true);
}

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

Tiio::Writer *Tiio::makeTifWriter()
{
#ifdef _DEBUG
	TIFFSetErrorHandler(MyErrorHandler);
	TIFFSetWarningHandler(MyWarningHandler);
#endif

	return new TifWriter();
}