/* * File:	ximajpg.h * Purpose:	JPG Image Class Loader and Writer *//* === C R E D I T S  &  D I S C L A I M E R S ============== * CxImageJPG (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it * Permission is given by the author to freely redistribute and include * this code in any program as long as this credit is given where due. * * CxImage version 5.99a 08/Feb/2004 * See the file history.htm for the complete bugfix and news report. * * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes * * Special thanks to Chris Shearer Cooper for CxFileJpg tips & code * * EXIF support based on jhead-1.8 by Matthias Wandel <mwandel(at)rim(dot)net> * * original CImageJPG  and CImageIterator implementation are: * Copyright:	(c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx> * * This software is based in part on the work of the Independent JPEG Group. * Copyright (C) 1991-1998, Thomas G. Lane. * * COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY * OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES * THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE * OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED * CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT * THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY * SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL * PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. * * Use at your own risk! * ========================================================== */#if !defined(__ximaJPEG_h)#define __ixmaJPEG_h#include "ximage.h"#if CXIMAGE_SUPPORT_JPG#define CXIMAGEJPG_SUPPORT_EXIF 1extern "C" { #include "../jpeg/jpeglib.h" #include "../jpeg/jerror.h"}class DLL_EXP CxImageJPG: public CxImage{public:	CxImageJPG();	~CxImageJPG() {};//	bool Load(const char * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_JPG);}//	bool Save(const char * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_JPG);}	bool Decode(CxFile * hFile);	bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }#if CXIMAGE_SUPPORT_ENCODE	bool Encode(CxFile * hFile);	bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }#endif // CXIMAGE_SUPPORT_ENCODE/* * EXIF support based on jhead-1.8 by Matthias Wandel <mwandel(at)rim(dot)net> */#if CXIMAGEJPG_SUPPORT_EXIF#define MAX_COMMENT 1000#define MAX_SECTIONS 20typedef struct tag_ExifInfo {	char  Version      [5];    char  CameraMake   [32];    char  CameraModel  [40];    char  DateTime     [20];    int   Height, Width;    int   Orientation;    int   IsColor;    int   Process;    int   FlashUsed;    float FocalLength;    float ExposureTime;    float ApertureFNumber;    float Distance;    float CCDWidth;    float ExposureBias;    int   Whitebalance;    int   MeteringMode;    int   ExposureProgram;    int   ISOequivalent;    int   CompressionLevel;	float FocalplaneXRes;	float FocalplaneYRes;	float FocalplaneUnits;	float Xresolution;	float Yresolution;	float ResolutionUnit;	float Brightness;    char  Comments[MAX_COMMENT];    unsigned char * ThumbnailPointer;  /* Pointer at the thumbnail */    unsigned ThumbnailSize;     /* Size of thumbnail. */	bool  IsExif;} EXIFINFO;//--------------------------------------------------------------------------// JPEG markers consist of one or more 0xFF bytes, followed by a marker// code byte (which is not an FF).  Here are the marker codes of interest// in this program.  (See jdmarker.c for a more complete list.)//--------------------------------------------------------------------------#define M_SOF0  0xC0            // Start Of Frame N#define M_SOF1  0xC1            // N indicates which compression process#define M_SOF2  0xC2            // Only SOF0-SOF2 are now in common use#define M_SOF3  0xC3#define M_SOF5  0xC5            // NB: codes C4 and CC are NOT SOF markers#define M_SOF6  0xC6#define M_SOF7  0xC7#define M_SOF9  0xC9#define M_SOF10 0xCA#define M_SOF11 0xCB#define M_SOF13 0xCD#define M_SOF14 0xCE#define M_SOF15 0xCF#define M_SOI   0xD8            // Start Of Image (beginning of datastream)#define M_EOI   0xD9            // End Of Image (end of datastream)#define M_SOS   0xDA            // Start Of Scan (begins compressed data)#define M_JFIF  0xE0            // Jfif marker#define M_EXIF  0xE1            // Exif marker#define M_COM   0xFE            // COMment class CxExifInfo{typedef struct tag_Section_t{    BYTE*    Data;    int      Type;    unsigned Size;} Section_t;public:	EXIFINFO* m_exifinfo;	char m_szLastError[256];	CxExifInfo(EXIFINFO* info = NULL);	~CxExifInfo();	bool DecodeExif(CxFile * hFile);protected:	bool process_EXIF(unsigned char * CharBuf, unsigned int length);	void process_COM (const BYTE * Data, int length);	void process_SOFn (const BYTE * Data, int marker);	int Get16u(void * Short);	int Get16m(void * Short);	long Get32s(void * Long);	unsigned long Get32u(void * Long);	double ConvertAnyFormat(void * ValuePtr, int Format);	bool ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength,                           EXIFINFO * const pInfo, unsigned char ** const LastExifRefdP);	int ExifImageWidth;	int MotorolaOrder;	Section_t Sections[MAX_SECTIONS];	int SectionsRead;	bool freeinfo;};	EXIFINFO m_exifinfo;	bool DecodeExif(CxFile * hFile);	bool DecodeExif(FILE * hFile) { CxIOFile file(hFile); return DecodeExif(&file); }#endif //CXIMAGEJPG_SUPPORT_EXIF//////////////////////////////////////////////////////////////////////////////////////////////////////////////        C x F i l e J p g         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// thanks to Chris Shearer Cooper <cscooper(at)frii(dot)com>class CxFileJpg : public jpeg_destination_mgr, public jpeg_source_mgr	{public:	enum { eBufSize = 4096 };	CxFileJpg(CxFile* pFile)	{        m_pFile = pFile;		init_destination = InitDestination;		empty_output_buffer = EmptyOutputBuffer;		term_destination = TermDestination;		init_source = InitSource;		fill_input_buffer = FillInputBuffer;		skip_input_data = SkipInputData;		resync_to_restart = jpeg_resync_to_restart; // use default method		term_source = TermSource;		next_input_byte = NULL; //* => next byte to read from buffer 		bytes_in_buffer = 0;	//* # of bytes remaining in buffer 		m_pBuffer = new unsigned char[eBufSize];	}	~CxFileJpg()	{		delete [] m_pBuffer;	}	static void InitDestination(j_compress_ptr cinfo)	{		CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;		pDest->next_output_byte = pDest->m_pBuffer;		pDest->free_in_buffer = eBufSize;	}	static boolean EmptyOutputBuffer(j_compress_ptr cinfo)	{		CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;		if (pDest->m_pFile->Write(pDest->m_pBuffer,1,eBufSize)!=(size_t)eBufSize)			ERREXIT(cinfo, JERR_FILE_WRITE);		pDest->next_output_byte = pDest->m_pBuffer;		pDest->free_in_buffer = eBufSize;		return TRUE;	}	static void TermDestination(j_compress_ptr cinfo)	{		CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;		size_t datacount = eBufSize - pDest->free_in_buffer;		/* Write any data remaining in the buffer */		if (datacount > 0) {			if (!pDest->m_pFile->Write(pDest->m_pBuffer,1,datacount))				ERREXIT(cinfo, JERR_FILE_WRITE);		}		pDest->m_pFile->Flush();		/* Make sure we wrote the output file OK */		if (pDest->m_pFile->Error()) ERREXIT(cinfo, JERR_FILE_WRITE);		return;	}	static void InitSource(j_decompress_ptr cinfo)	{		CxFileJpg* pSource = (CxFileJpg*)cinfo->src;		pSource->m_bStartOfFile = TRUE;	}	static boolean FillInputBuffer(j_decompress_ptr cinfo)	{		size_t nbytes;		CxFileJpg* pSource = (CxFileJpg*)cinfo->src;		nbytes = pSource->m_pFile->Read(pSource->m_pBuffer,1,eBufSize);		if (nbytes <= 0){			if (pSource->m_bStartOfFile)	//* Treat empty input file as fatal error 				ERREXIT(cinfo, JERR_INPUT_EMPTY);			WARNMS(cinfo, JWRN_JPEG_EOF);			// Insert a fake EOI marker 			pSource->m_pBuffer[0] = (JOCTET) 0xFF;			pSource->m_pBuffer[1] = (JOCTET) JPEG_EOI;			nbytes = 2;		}		pSource->next_input_byte = pSource->m_pBuffer;		pSource->bytes_in_buffer = nbytes;		pSource->m_bStartOfFile = FALSE;		return TRUE;	}	static void SkipInputData(j_decompress_ptr cinfo, long num_bytes)	{		CxFileJpg* pSource = (CxFileJpg*)cinfo->src;		if (num_bytes > 0){			while (num_bytes > (long)pSource->bytes_in_buffer){				num_bytes -= (long)pSource->bytes_in_buffer;				FillInputBuffer(cinfo);				// note we assume that fill_input_buffer will never return FALSE,				// so suspension need not be handled.			}			pSource->next_input_byte += (size_t) num_bytes;			pSource->bytes_in_buffer -= (size_t) num_bytes;		}	}	static void TermSource(j_decompress_ptr cinfo)	{		return;	}protected:    CxFile  *m_pFile;	unsigned char *m_pBuffer;	bool m_bStartOfFile;};public:	enum CODEC_OPTION	{		ENCODE_BASELINE = 0x1,		ENCODE_ARITHMETIC = 0x2,		ENCODE_GRAYSCALE = 0x4,		ENCODE_OPTIMIZE = 0x8,		ENCODE_PROGRESSIVE = 0x10,		ENCODE_LOSSLESS = 0x20,		ENCODE_SMOOTHING = 0x40,		DECODE_GRAYSCALE = 0x80,		DECODE_QUANTIZE = 0x100,		DECODE_DITHER = 0x200,		DECODE_ONEPASS = 0x400,		DECODE_NOSMOOTH = 0x800	}; 	int m_nPredictor;	int m_nPointTransform;	int m_nSmoothing;	int m_nQuantize;	J_DITHER_MODE m_nDither;};#endif#endif