////////////////////////////////////////////////////////////////////////////////
//
//	GIFFile - A C++ class to allow reading and writing of GIF Images
//
//	It is based on code from Programming for Graphics Files	by John Levine
//
//	This is free to use and modify provided proper credit is given
//
//	This reads GIF 87a and 89a, writes only 87a.
//	This writes only 8-bit GIF files. 256 colors.
//	You provide the palette and the palettized image. 
//	This does not do quantization.
//
//
// use :
//
//	Reading:
//
//	GIFFile theGifObject;
//
//	BYTE * buf;
//	buf=theGifObject.GIFReadFileToRGB(path,&width,&height);
//
//	if (buf!=NULL) {
//		// you now have a buffer of width * height RGB pixels
//		// do whatever you like with it
//	}	else {
//		// error text
//		AfxMessageBox(theGifObject.m_GIFErrorText);
//	}
//
//	//delete the buffer when you're done
//	delete [] buf;
//
///////
//
//	Writing :
//
//	GIFFile theGifThing;
//	
//	if (!theGifThing.GIFWriteFileFrom256Color(buffer,	// BYTE * of the 256-color buffer
//							filename,					// name to save as
//							m_width,					// pixels
//							m_height,					// rows
//							0,							// background color
//							red, green, blue)) {		// arrays of 256 ints each that represent the
//														// 256-color palette for this image.
//		//Error!
//		AfxMessageBox(theGifThing.m_GIFErrorText);
//	} else {
//		// success!
//	}
//
////////////////////////////////////////////////////////////////////////////////

#ifndef GIFHDRH
#define GIFHDRH

#define MAXCOLORMAPSIZE	256
#define CM_RED	0
#define CM_GREEN 1
#define CM_BLUE 2
#define UCHAR unsigned char
#define MAX_LZW_BITS	12

#define INTERLACE	0x40
#define LOCALCOLORMAP 0x80
#define BitSet(byte,bit) (((byte) & (bit))==(bit))
#define ReadOK(file,buffer,len) (fread(buffer,len,1,file)!=0)
#define LM_to_uint(a,b)	(((b)<<8)|(a))

typedef short int		code_int;	/* was int */
typedef long int		count_int;
typedef unsigned char   pixval;

static void ReadGIF (FILE*fd);
static int  ReadColorMap (FILE *fd, int number, UCHAR buffer[3][MAXCOLORMAPSIZE]);
static int  DoExtension (FILE *fd,int label);
static int  GetDataBlock (FILE *fd, UCHAR *buf);
static int  GetCode (FILE *fd, int code_size, int flag);
static int  LZWReadByte (FILE *fd,int flag, int  input_code_size);

static BOOL ReadImage(	FILE *fd,
						BYTE  * bigMemBuf,
						int width, int height,
						UCHAR cmap[3][MAXCOLORMAPSIZE],
						int interlace);
BYTE * MakeColormappedGrayscale(BYTE *inBuf,
								  UINT inWidth,
								  UINT inHeight,
								  UINT inWidthBytes,
								  UINT colors,
								  RGBQUAD* colormap);

#endif // GIFHDRH
//////////

class GIFFile 
{
public:
	GIFFile();
	~GIFFile();

public:
	CString m_GIFErrorText;

public:

	// write a file
	BOOL GIFWriteFileFrom256Color(BYTE  * buf,
							CString name,
							int GWidth, 
							int GHeight,
							int BackGround,
							int Red[], int Green[], int Blue[]);

	// read to RGB
	BYTE * GIFReadFileToRGB(CString path, 
							UINT *width, 
							UINT *height);

	// find size of file
	void GIFGetDimensions(CString path, 
							UINT *width, 
							UINT *height);

private:

	void BumpPixel (  );
	int  GIFNextPixel ( );
	void Putword ( int w, FILE* fp );
	void compress ( int init_bits, FILE* outfile);
	void output ( code_int code );
	void cl_block (  );
	void cl_hash ( count_int hsize );
	void writeerr (  );
	void char_init (  );
	void char_out ( int c );
	void flush_char (  );
};

// 讀 PCX 圖像的聲明
#define MAX_BUFF_SIZE           32768 // 32K 
// Header signatutes for various resources 
#define PCX_MARK                0x0A
// Macro to determine if image is a PCX 
#define CHECK_PCX(type)         ( (type)==PCX_MARK )
// Macro to find the image colors  
#define IMAGE_COLORS(x,y)       ( 1 << ((x) * (y)) )
typedef struct pcxheader
   {
      BYTE byManufacturer;
      BYTE byVersion;
      BYTE byEncoding;
      BYTE byBits;
      WORD wLeft;
      WORD wTop;
      WORD wRight;
      WORD wBottom;
      WORD wXResolution;
      WORD wYResolution;
      BYTE byPalette[48];
      BYTE byReserved;
      BYTE byPlanes;
      WORD wLineBytes;
      WORD wPaletteType;
      WORD wScrWidth;
      WORD wScrDepth;
      BYTE byFiller[54];
   }  PCXHEADER;

typedef struct pcxd_var
   {
      BYTE* lpDataBuff;
      BYTE* lpBgnBuff;
      BYTE* lpEndBuff;
      DWORD dwDataLen;
      DWORD wMemLen;
      WORD  wWidth;
      WORD  wDepth;
      WORD  wLineBytes;
      WORD  wPlanes;
      WORD  wSrcBits;
      WORD  wNewBits;
      BOOL  bEOF;
   }  PCXD_VAR;
typedef PCXD_VAR FAR *LPPCXD_VAR;

typedef struct pcxc_var
   {
      BYTE* lpDataBuff;
      BYTE* lpEndBuff;
      WORD  wWidth;
      WORD  wDepth;
      WORD  wLineBytes;
      WORD  wPlanes;
      WORD  wBits;
      WORD  wByteCnt;
   }  PCXC_VAR;
typedef PCXC_VAR FAR *LPPCXC_VAR;
               
void iDecodeLine(LPPCXD_VAR lpPCXDVar,BYTE* lpTemp);
void iEncodeLine(CFile * ExportFile,LPPCXC_VAR lpPCXCVar,BYTE* lpTemp);

BOOL ReadPcxImage(CFile * iFile,BYTE *iTempFile, LPPCXD_VAR lpPCXDVar,long wWidthBytes);
BOOL WritePcxImage(CFile * OutFile,BYTE *iTempFile,LPPCXC_VAR lpPCXCVar,long wWidthBytes);