#ifndef TNZ4_H
#define TNZ4_H

#include <assert.h>
#include <stdlib.h>
#include <sys/types.h>

#if defined(MACOSX)
#include <sys/malloc.h>
#else
#include <malloc.h>
#endif

#define UCHAR unsigned char
#define USHORT unsigned short

#include "tmachine.h"
#include "tnztypes.h"

#include "tfile_io.h"

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

#define NIL 0

#define FALSE 0
#define TRUE 1
#define TBOOL int

	typedef struct LPIXEL {
#ifdef _WIN32
	unsigned char b, g, r, m;
#elif defined(__sgi)
	unsigned char m, b, g, r;
#elif defined(LINUX)
	unsigned char r, g, b, m;
#elif defined(MACOSX)
	unsigned char m, r, g, b;
#else
#error Not	yet implemented
#endif
} LPIXEL;

typedef struct SPIXEL {
#ifdef _WIN32
	unsigned short b, g, r, m;
#elif defined(__sgi)
	unsigned short m, b, g, r;
#elif defined(LINUX)
	unsigned short r, g, b, m;
#elif defined(MACOSX)
	unsigned char m, r, g, b;
#else
#error Not	yet implemented
#endif
} SPIXEL;

#define UINT TINT32

typedef LPIXEL GL_COLOR;

typedef struct IMAGE {
	int xsize, ysize;
	int xSBsize, ySBsize;
	int type;
	UCHAR *buffer;
	double x_dpi, y_dpi;
} IMAGE;

#define TOONZRGB (1234)
#define TOONZRGB64 (4567)

#define TMALLOC(ptr, elem) \
	(ptr) = (void *)malloc((elem) * sizeof(*(ptr)));
#define TCALLOC(ptr, elem) \
	(ptr) = (void *)calloc((elem), sizeof(*(ptr)));
#define TREALLOC(ptr, elem)                                          \
	{                                                                \
		if (ptr)                                                     \
			(ptr) = (void *)realloc((ptr), (elem) * sizeof(*(ptr))); \
		else                                                         \
			(ptr) = (void *)malloc((elem) * sizeof(*(ptr)));         \
	}
#define TFREE(ptr)     \
	{                  \
		if (ptr) {     \
			free(ptr); \
			ptr = NIL; \
		}              \
	}

#define MAX(A, B) ((A) > (B) ? (A) : (B))
#define MIN(A, B) ((A) < (B) ? (A) : (B))

#define NOT_LESS_THAN(MIN, X) \
	{                         \
		if ((X) < (MIN))      \
			(X) = (MIN);      \
	}
#define NOT_MORE_THAN(MAX, X) \
	{                         \
		if ((X) > (MAX))      \
			(X) = (MAX);      \
	}

#define CROP(X, MIN, MAX) (X < MIN ? MIN : (X > MAX ? MAX : X))

#ifdef _WIN32
#define LPIXEL_TO_BGRM(X) (X)
#else
#if TNZ_LITTLE_ENDIAN
#define LPIXEL_TO_BGRM(X) (((TUINT32)(X) >> 8) | ((TUINT32)(X) << 24))
/*
    #define BGRM_TO_LPIXEL(X)  (((TUINT32)(X)<<8) | ((TUINT32)(X)>>24))
*/
#else
#define LPIXEL_TO_BGRM(X) (((TUINT32)(X) << 8) | ((TUINT32)(X) >> 24))
/*
    #define BGRM_TO_LPIXEL(X)  (((TUINT32)(X)>>8) | ((TUINT32)(X)<<24))
*/
#endif
#endif

#define BYTE_FROM_USHORT_MAGICFAC (256U * 255U + 1U)
#define PIX_USHORT_FROM_BYTE(X) ((X) | ((X) << 8))
#define PIX_BYTE_FROM_USHORT(X) \
	((((X)*BYTE_FROM_USHORT_MAGICFAC) + (1 << 23)) >> 24)

#define PIX_DITHER_BYTE_FROM_USHORT(X, R)         \
	(((((X)*BYTE_FROM_USHORT_MAGICFAC) -          \
	   (((X)*BYTE_FROM_USHORT_MAGICFAC) >> 24)) + \
	  (R)) >>                                     \
	 24)

/*---------------------------------------------------------------------------*/

short swap_short(short s);

TINT32 swap_TINT32(TINT32 s);

USHORT swap_ushort(USHORT x);

/*ULONG swap_uTLong (ULONG x);*/

/*---------------------------------------------------------------------------*/

/*! These functions are implemented in .cpp files, and allocate any buffer 
using new operator, so it's safe return img->buffer to .cpp units */

IMAGE *new_img();

void free_img(IMAGE *);

int allocate_pixmap(IMAGE *img, int w, int h);

#endif