#include "HGImgFmt.h"
#include "HGJpeg.h"
#include "HGBmp.h"
#include "HGPng.h"
#include "HGTiff.h"
#include "HGPdf.h"
#include "HGOfd.h"
#include "HGGif.h"
#include "HGPnm.h"
#include "../base/HGInc.h"
#include <string>
#if defined(HG_CMP_MSC)
#include "FreeImage.h"
#endif

// -----------------FREEIMAGE---------------------

#if defined(HG_CMP_MSC)
static HGResult FBITMAPToHGImage(FIBITMAP *dib, HGUInt imgType, HGUInt imgOrigin, HGImage *image)
{
    assert(NULL != dib);
    assert(NULL != image);

    HGUInt bpp = FreeImage_GetBPP(dib);
    if (0 == imgType)
    {
        imgType = HGBASE_IMGTYPE_RGB;
        if (1 == bpp)
            imgType = HGBASE_IMGTYPE_BINARY;
        else if (8 == bpp)
            imgType = HGBASE_IMGTYPE_GRAY;
        else if (32 == bpp)
            imgType = HGBASE_IMGTYPE_RGBA;
    }

    if (0 == imgOrigin)
    {
        imgOrigin = HGBASE_IMGORIGIN_TOP;
    }

    HGImageInfo imgInfo;
    imgInfo.width = FreeImage_GetWidth(dib);
    imgInfo.height = FreeImage_GetHeight(dib);
    imgInfo.type = 0;
    imgInfo.widthStep = FreeImage_GetPitch(dib);
    imgInfo.origin = HGBASE_IMGORIGIN_BOTTOM;

    if (1 == bpp)
        imgInfo.type = HGBASE_IMGTYPE_BINARY;
    else if (8 == bpp)
        imgInfo.type = HGBASE_IMGTYPE_GRAY;
    else if (24 == bpp)
        imgInfo.type = HGBASE_IMGTYPE_BGR;
    else if (32 == bpp)
        imgInfo.type = HGBASE_IMGTYPE_BGRA;

    if (0 != imgInfo.type)
    {
        HGResult ret = HGBase_CreateImageFromData(FreeImage_GetBits(dib), &imgInfo, NULL, imgType, imgOrigin, image);
        if (HGBASE_ERR_OK == ret)
        {
            HGBase_SetImageDpi(*image, (HGUInt)((double)FreeImage_GetDotsPerMeterX(dib) / 39.3700787 + 0.5),
                               (HGUInt)((double)FreeImage_GetDotsPerMeterY(dib) / 39.3700787 + 0.5));
        }

        return ret;
    }

    FIBITMAP *dib2 = FreeImage_ConvertTo32Bits(dib);
    if (NULL == dib2)
    {
        return HGBASE_ERR_FAIL;
    }

    HGImageInfo imgInfo2;
    imgInfo2.width = FreeImage_GetWidth(dib2);
    imgInfo2.height = FreeImage_GetHeight(dib2);
    imgInfo2.type = HGBASE_IMGTYPE_BGRA;
    imgInfo2.widthStep = FreeImage_GetPitch(dib2);
    imgInfo2.origin = HGBASE_IMGORIGIN_BOTTOM;

    HGResult ret = HGBase_CreateImageFromData(FreeImage_GetBits(dib2), &imgInfo2, NULL, imgType, imgOrigin, image);
    if (HGBASE_ERR_OK == ret)
    {
        HGBase_SetImageDpi(*image, (HGUInt)((double)FreeImage_GetDotsPerMeterX(dib2) / 39.3700787 + 0.5),
                           (HGUInt)((double)FreeImage_GetDotsPerMeterY(dib2) / 39.3700787 + 0.5));
    }

    FreeImage_Unload(dib2);
    return ret;
}

static HGResult HGImageToFIBITMAP(HGImage image, FREE_IMAGE_FORMAT fif, FIBITMAP **dib)
{
    assert(NULL != image);
    assert(NULL != dib);

    HGImage image2 = image;
    HGImageInfo imgInfo;
    HGBase_GetImageInfo(image2, &imgInfo);

    if ((HGBASE_IMGTYPE_RGB == imgInfo.type) || (HGBASE_IMGTYPE_RGBA == imgInfo.type)
            || (HGBASE_IMGTYPE_BINARY == imgInfo.type && FIF_TARGA == fif))
    {
        HGUInt type = HGBASE_IMGTYPE_BGR;
        if (HGBASE_IMGTYPE_RGBA == imgInfo.type)
            type = HGBASE_IMGTYPE_BGRA;
        else if (HGBASE_IMGTYPE_BINARY == imgInfo.type && FIF_TARGA == fif)
            type = HGBASE_IMGTYPE_GRAY;

        HGImageRoi imageRoi;
        HGBase_GetImageROI(image, &imageRoi);
        HGBase_ResetImageROI(image);
        HGResult ret = HGBase_CloneImage(image, type, imgInfo.origin, &image2);
        HGBase_SetImageROI(image, &imageRoi);
        if (HGBASE_ERR_OK != ret)
        {
            return ret;
        }

        HGBase_GetImageInfo(image2, &imgInfo);
    }

    HGByte *data = NULL;
    HGBase_GetImageData(image2, &data);
    HGUInt xDpi, yDpi;
    HGBase_GetImageDpi(image2, &xDpi, &yDpi);

    unsigned int bpp = 1;
    if (HGBASE_IMGTYPE_GRAY == imgInfo.type)
        bpp = 8;
    else if (HGBASE_IMGTYPE_BGR == imgInfo.type)
        bpp = 24;
    else if (HGBASE_IMGTYPE_BGRA == imgInfo.type)
        bpp = 32;
    else
        assert(HGBASE_IMGTYPE_BINARY == imgInfo.type);

    *dib = FreeImage_ConvertFromRawBitsEx(TRUE, data, FIT_BITMAP, imgInfo.width, imgInfo.height, imgInfo.widthStep,
                                 bpp, 0, 0, 0, (HGBASE_IMGORIGIN_TOP == imgInfo.origin));
    if (NULL != *dib)
    {
        FreeImage_SetDotsPerMeterX(*dib, (uint32_t)((double)xDpi * 39.3700787 + 0.5));
        FreeImage_SetDotsPerMeterY(*dib, (uint32_t)((double)yDpi * 39.3700787 + 0.5));
    }

    if (image2 != image)
    {
        HGBase_DestroyImage(image2);
    }

    return (NULL != *dib ? HGBASE_ERR_OK : HGBASE_ERR_FAIL);
}

static HGResult CheckFIFile(const HGChar* fileName, FREE_IMAGE_FORMAT fif, HGBool* isTrue)
{
    if (NULL == fileName || NULL == isTrue)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    if (!FreeImage_Validate(fif, fileName))
    {
        return HGBASE_ERR_FAIL;
    }

    *isTrue = HGTRUE;
    return HGBASE_ERR_OK;
}

static HGResult LoadFIImage(const HGChar* fileName, FREE_IMAGE_FORMAT fif, HGImgFmtLoadInfo* info,
    HGUInt imgType, HGUInt imgOrigin, HGImage* image)
{
    if (NULL == fileName)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    if (NULL == image)
    {
        if (0 != imgType || 0 != imgOrigin)
        {
            return HGBASE_ERR_INVALIDARG;
        }
    }
    else
    {
        if (0 != imgType && HGBASE_IMGTYPE_BINARY != imgType && HGBASE_IMGTYPE_GRAY != imgType
            && HGBASE_IMGTYPE_BGR != imgType && HGBASE_IMGTYPE_RGB != imgType
            && HGBASE_IMGTYPE_BGRA != imgType && HGBASE_IMGTYPE_RGBA != imgType)
        {
            return HGBASE_ERR_INVALIDARG;
        }

        if (0 != imgOrigin && HGBASE_IMGORIGIN_TOP != imgOrigin && HGBASE_IMGORIGIN_BOTTOM != imgOrigin)
        {
            return HGBASE_ERR_INVALIDARG;
        }
    }

#if defined(HG_CMP_MSC)
    if (0 != _access(fileName, 0))
#else
    if (0 != access(fileName, 0))
#endif
    {
        return HGBASE_ERR_FILENOTEXIST;
    }

    FIBITMAP *dib = FreeImage_Load(fif, fileName);
    if (NULL == dib)
    {
        return HGBASE_ERR_FAIL;
    }

    if (NULL != info)
    {
        info->width = FreeImage_GetWidth(dib);
        info->height = FreeImage_GetHeight(dib);
        info->bpp = FreeImage_GetBPP(dib);
        info->xDpi = (HGUInt)((double)FreeImage_GetDotsPerMeterX(dib) / 39.3700787 + 0.5);
        info->yDpi = (HGUInt)((double)FreeImage_GetDotsPerMeterY(dib) / 39.3700787 + 0.5);
    }

    if (NULL != image)
    {
        HGResult ret = FBITMAPToHGImage(dib, imgType, imgOrigin, image);
        if (HGBASE_ERR_OK != ret)
        {
            FreeImage_Unload(dib);
            return ret;
        }
    }

    FreeImage_Unload(dib);
    return HGBASE_ERR_OK;
}

static HGResult SaveFIImage(HGImage image, const HGImgFmtSaveInfo* info, const HGChar* fileName, FREE_IMAGE_FORMAT fif)
{
    if (NULL == image || NULL == fileName)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    if (!FreeImage_FIFSupportsWriting(fif))
    {
        return HGBASE_ERR_FAIL;
    }

    if (NULL != info)
    {
        // 检查合法性
    }

    FIBITMAP *dib = NULL;
    HGResult ret = HGImageToFIBITMAP(image, fif, &dib);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    if (!FreeImage_Save(fif, dib, fileName))
    {
        FreeImage_Unload(dib);
        return HGBASE_ERR_FAIL;
    }

    FreeImage_Unload(dib);
    return HGBASE_ERR_OK;
}
#endif

static HGResult CheckTgaFile(const HGChar* fileName, HGBool* isTga)
{
#if defined(HG_CMP_MSC)
    return CheckFIFile(fileName, FIF_TARGA, isTga);
#else
    return HGBASE_ERR_FAIL;
#endif
}

static HGResult LoadTgaImage(const HGChar* fileName, HGImgFmtLoadInfo* info,
    HGUInt imgType, HGUInt imgOrigin, HGImage* image)
{
#if defined(HG_CMP_MSC)
    return LoadFIImage(fileName, FIF_TARGA, info, imgType, imgOrigin, image);
#else
    return HGBASE_ERR_FAIL;
#endif
}

static HGResult SaveTgaImage(HGImage image, const HGImgFmtSaveInfo* info, const HGChar* fileName)
{
#if defined(HG_CMP_MSC)
    return SaveFIImage(image, info, fileName, FIF_TARGA);
#else
    return HGBASE_ERR_FAIL;
#endif
}

static HGResult CheckPcxFile(const HGChar* fileName, HGBool* isPcx)
{
#if defined(HG_CMP_MSC)
    return CheckFIFile(fileName, FIF_PCX, isPcx);
#else
    return HGBASE_ERR_FAIL;
#endif
}

static HGResult LoadPcxImage(const HGChar* fileName, HGImgFmtLoadInfo* info,
    HGUInt imgType, HGUInt imgOrigin, HGImage* image)
{
#if defined(HG_CMP_MSC)
    return LoadFIImage(fileName, FIF_PCX, info, imgType, imgOrigin, image);
#else
    return HGBASE_ERR_FAIL;
#endif
}

static HGResult SavePcxImage(HGImage image, const HGImgFmtSaveInfo* info, const HGChar* fileName)
{
#if defined(HG_CMP_MSC)
    return SaveFIImage(image, info, fileName, FIF_PCX);
#else
    return HGBASE_ERR_FAIL;
#endif
}

static HGResult CheckRasFile(const HGChar* fileName, HGBool* isRas)
{
#if defined(HG_CMP_MSC)
    return CheckFIFile(fileName, FIF_RAS, isRas);
#else
    return HGBASE_ERR_FAIL;
#endif
}

static HGResult LoadRasImage(const HGChar* fileName, HGImgFmtLoadInfo* info,
    HGUInt imgType, HGUInt imgOrigin, HGImage* image)
{
#if defined(HG_CMP_MSC)
    return LoadFIImage(fileName, FIF_RAS, info, imgType, imgOrigin, image);
#else
    return HGBASE_ERR_FAIL;
#endif
}

static HGResult SaveRasImage(HGImage image, const HGImgFmtSaveInfo* info, const HGChar* fileName)
{
#if defined(HG_CMP_MSC)
    return SaveFIImage(image, info, fileName, FIF_RAS);
#else
    return HGBASE_ERR_FAIL;
#endif
}

// -----------------FREEIMAGE---------------------

struct HGImgFmtReaderImpl
{
	HGImgFmtReaderImpl()
	{
		fmtType = 0;
		handle = NULL;
	}

	std::string fileName;
	HGUInt fmtType;
	HGPointer handle;
	HGGifLoadInfo gifLoadInfo;
};

struct HGImgFmtWriterImpl
{
	HGImgFmtWriterImpl()
	{
		fmtType = 0;
		handle = NULL;
		write = HGFALSE;
	}

	std::string fileName;
	HGUInt fmtType;
	HGPointer handle;
    HGBool write; // 用于标记JPEG、BMP、PNG、PNM、TGA、PCX和RAS是否已经写入
};

HGResult HGAPI HGImgFmt_GetImgFmtType(const HGChar* fileName, HGUInt* fmtType)
{
	if (NULL == fileName || NULL == fmtType)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGBool isJpeg = HGFALSE;
	HGResult ret = HGImgFmt_CheckJpegFile(fileName, &isJpeg);
	if (isJpeg)
	{
		*fmtType = HGIMGFMT_TYPE_JPEG;
		return HGBASE_ERR_OK;
	}

	HGBool isBmp = HGFALSE;
	ret = HGImgFmt_CheckBmpFile(fileName, &isBmp);
	if (isBmp)
	{
		*fmtType = HGIMGFMT_TYPE_BMP;
		return HGBASE_ERR_OK;
	}

	HGBool isPng = HGFALSE;
	ret = HGImgFmt_CheckPngFile(fileName, &isPng);
	if (isPng)
	{
		*fmtType = HGIMGFMT_TYPE_PNG;
		return HGBASE_ERR_OK;
	}

	HGBool isTiff = HGFALSE;
	ret = HGImgFmt_CheckTiffFile(fileName, &isTiff);
	if (isTiff)
	{
		*fmtType = HGIMGFMT_TYPE_TIFF;
		return HGBASE_ERR_OK;
	}

	HGBool isPdf = HGFALSE;
	ret = HGImgFmt_CheckPdfFile(fileName, &isPdf);
	if (isPdf)
	{
		*fmtType = HGIMGFMT_TYPE_PDF;
		return HGBASE_ERR_OK;
	}

	HGBool isOfd = HGFALSE;
	ret = HGImgFmt_CheckOfdFile(fileName, &isOfd);
	if (isOfd)
	{
		*fmtType = HGIMGFMT_TYPE_OFD;
		return HGBASE_ERR_OK;
	}

	HGBool isGif = HGFALSE;
	ret = HGImgFmt_CheckGifFile(fileName, &isGif);
	if (isGif)
	{
		*fmtType = HGIMGFMT_TYPE_GIF;
		return HGBASE_ERR_OK;
	}

	HGBool isPnm = HGFALSE;
	ret = HGImgFmt_CheckPnmFile(fileName, &isPnm);
	if (isPnm)
	{
		*fmtType = HGIMGFMT_TYPE_PNM;
		return HGBASE_ERR_OK;
	}

    HGBool isTga = HGFALSE;
    ret = CheckTgaFile(fileName, &isTga);
    if (isTga)
    {
        *fmtType = HGIMGFMT_TYPE_TGA;
        return HGBASE_ERR_OK;
    }

    HGBool isPcx = HGFALSE;
    ret = CheckPcxFile(fileName, &isPcx);
    if (isPcx)
    {
        *fmtType = HGIMGFMT_TYPE_PCX;
        return HGBASE_ERR_OK;
    }

    HGBool isRas = HGFALSE;
    ret = CheckRasFile(fileName, &isRas);
    if (isRas)
    {
        *fmtType = HGIMGFMT_TYPE_RAS;
        return HGBASE_ERR_OK;
    }

	return ret;
}

HGResult HGAPI HGImgFmt_GetImgFmtTypeFromFileName(const HGChar* fileName, HGUInt* fmtType)
{
	if (NULL == fileName || NULL == fmtType)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const char* p = strrchr(fileName, '.');
	if (NULL == p)
	{
		return HGBASE_ERR_INVALIDARG;
	}

#if defined(HG_CMP_MSC)
	if (0 == _stricmp(p, ".jpe") || 0 == _stricmp(p, ".jpg") || 0 == _stricmp(p, ".jpeg"))
	{
		*fmtType = HGIMGFMT_TYPE_JPEG;
		return HGBASE_ERR_OK;
	}

	if (0 == _stricmp(p, ".bmp") || 0 == _stricmp(p, ".dib"))
	{
		*fmtType = HGIMGFMT_TYPE_BMP;
		return HGBASE_ERR_OK;
	}

	if (0 == _stricmp(p, ".png"))
	{
		*fmtType = HGIMGFMT_TYPE_PNG;
		return HGBASE_ERR_OK;
	}

	if (0 == _stricmp(p, ".tif") || 0 == _stricmp(p, ".tiff"))
	{
		*fmtType = HGIMGFMT_TYPE_TIFF;
		return HGBASE_ERR_OK;
	}

	if (0 == _stricmp(p, ".pdf"))
	{
		*fmtType = HGIMGFMT_TYPE_PDF;
		return HGBASE_ERR_OK;
	}

	if (0 == _stricmp(p, ".ofd"))
	{
		*fmtType = HGIMGFMT_TYPE_OFD;
		return HGBASE_ERR_OK;
	}

	if (0 == _stricmp(p, ".gif"))
	{
		*fmtType = HGIMGFMT_TYPE_GIF;
		return HGBASE_ERR_OK;
	}

	if (0 == _stricmp(p, ".pbm") || 0 == _stricmp(p, ".pgm") || 0 == _stricmp(p, ".ppm"))
	{
		*fmtType = HGIMGFMT_TYPE_PNM;
		return HGBASE_ERR_OK;
	}

    if (0 == _stricmp(p, ".tga"))
    {
        *fmtType = HGIMGFMT_TYPE_TGA;
        return HGBASE_ERR_OK;
    }

    if (0 == _stricmp(p, ".pcx"))
    {
        *fmtType = HGIMGFMT_TYPE_PCX;
        return HGBASE_ERR_OK;
    }

    if (0 == _stricmp(p, ".ras"))
    {
        *fmtType = HGIMGFMT_TYPE_RAS;
        return HGBASE_ERR_OK;
    }
#else
	if (0 == strcasecmp(p, ".jpe") || 0 == strcasecmp(p, ".jpg") || 0 == strcasecmp(p, ".jpeg"))
	{
		*fmtType = HGIMGFMT_TYPE_JPEG;
		return HGBASE_ERR_OK;
	}

	if (0 == strcasecmp(p, ".bmp") || 0 == strcasecmp(p, ".dib"))
	{
		*fmtType = HGIMGFMT_TYPE_BMP;
		return HGBASE_ERR_OK;
	}

	if (0 == strcasecmp(p, ".png"))
	{
		*fmtType = HGIMGFMT_TYPE_PNG;
		return HGBASE_ERR_OK;
	}

	if (0 == strcasecmp(p, ".tif") || 0 == strcasecmp(p, ".tiff"))
	{
		*fmtType = HGIMGFMT_TYPE_TIFF;
		return HGBASE_ERR_OK;
	}

	if (0 == strcasecmp(p, ".pdf"))
	{
		*fmtType = HGIMGFMT_TYPE_PDF;
		return HGBASE_ERR_OK;
	}

	if (0 == strcasecmp(p, ".ofd"))
	{
		*fmtType = HGIMGFMT_TYPE_OFD;
		return HGBASE_ERR_OK;
	}

	if (0 == strcasecmp(p, ".gif"))
	{
		*fmtType = HGIMGFMT_TYPE_GIF;
		return HGBASE_ERR_OK;
	}

	if (0 == strcasecmp(p, ".pbm") || 0 == strcasecmp(p, ".pgm") || 0 == strcasecmp(p, ".ppm"))
	{
		*fmtType = HGIMGFMT_TYPE_PNM;
		return HGBASE_ERR_OK;
	}

    if (0 == strcasecmp(p, ".tga"))
    {
        *fmtType = HGIMGFMT_TYPE_TGA;
        return HGBASE_ERR_OK;
    }

    if (0 == strcasecmp(p, ".pcx"))
    {
        *fmtType = HGIMGFMT_TYPE_PCX;
        return HGBASE_ERR_OK;
    }

    if (0 == strcasecmp(p, ".ras"))
    {
        *fmtType = HGIMGFMT_TYPE_RAS;
        return HGBASE_ERR_OK;
    }
#endif

	return HGBASE_ERR_FAIL;
}

HGResult HGAPI HGImgFmt_IsMultiImgFmtType(HGUInt fmtType, HGBool* isMulti)
{
    if (fmtType < HGIMGFMT_TYPE_JPEG || fmtType > HGIMGFMT_TYPE_RAS || NULL == isMulti)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (HGIMGFMT_TYPE_JPEG == fmtType || HGIMGFMT_TYPE_BMP == fmtType || HGIMGFMT_TYPE_PNG == fmtType
        || HGIMGFMT_TYPE_PNM == fmtType || HGIMGFMT_TYPE_TGA == fmtType || HGIMGFMT_TYPE_PCX == fmtType
            || HGIMGFMT_TYPE_RAS == fmtType)
		*isMulti = HGFALSE;
	else
		*isMulti = HGTRUE;
	return HGBASE_ERR_OK;
}

HGResult HGAPI HGImgFmt_LoadImage(const HGChar* fileName, HGUInt fmtType, HGImgFmtLoadInfo* info,
	HGUInt imgType, HGUInt imgOrigin, HGImage* image)
{
    if (fmtType > HGIMGFMT_TYPE_RAS)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (HGIMGFMT_TYPE_JPEG == fmtType)
	{
		HGJpegLoadInfo jpegInfo;
		HGResult ret = HGImgFmt_LoadJpegImage(fileName, &jpegInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = jpegInfo.width;
			info->height = jpegInfo.height;
			info->bpp = jpegInfo.numComponents * 8;
			info->xDpi = 0;
			info->yDpi = 0;
			if (HGIMGFMT_JPEGDENUNIT_INCH == jpegInfo.densityUnit)
			{
				info->xDpi = jpegInfo.xDensity;
				info->yDpi = jpegInfo.yDensity;
			}
			else if (HGIMGFMT_JPEGDENUNIT_CENTIMETER == jpegInfo.densityUnit)
			{
				info->xDpi = (uint32_t)((double)jpegInfo.xDensity / 0.393700787 + 0.5);
				info->yDpi = (uint32_t)((double)jpegInfo.yDensity / 0.393700787 + 0.5);
			}
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_BMP == fmtType)
	{
		HGBmpLoadInfo bmpInfo;
		HGResult ret = HGImgFmt_LoadBmpImage(fileName, &bmpInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = bmpInfo.width;
			info->height = bmpInfo.height;
			info->bpp = bmpInfo.bitCount;
			info->xDpi = (uint32_t)((double)bmpInfo.xPelsPerMeter / 39.3700787 + 0.5);
			info->yDpi = (uint32_t)((double)bmpInfo.yPelsPerMeter / 39.3700787 + 0.5);
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_PNG == fmtType)
	{
		HGPngLoadInfo pngInfo;
		HGResult ret = HGImgFmt_LoadPngImage(fileName, &pngInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = pngInfo.width;
			info->height = pngInfo.height;
			info->bpp = pngInfo.pixelDepth;
			info->xDpi = 0;
			info->yDpi = 0;
			if (HGIMGFMT_PNGPHYSUNIT_METER == pngInfo.physUnitType)
			{
				info->xDpi = (uint32_t)((double)pngInfo.xPixelsPerUnit / 39.3700787 + 0.5);
				info->yDpi = (uint32_t)((double)pngInfo.yPixelsPerUnit / 39.3700787 + 0.5);
			}
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_TIFF == fmtType)
	{
		HGTiffLoadInfo tiffInfo;
		HGResult ret = HGImgFmt_LoadTiffImage(fileName, &tiffInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = tiffInfo.width;
			info->height = tiffInfo.height;
			info->bpp = tiffInfo.bitsPerSample * tiffInfo.samplesPerPixel;
			info->xDpi = 0;
			info->yDpi = 0;
			if (HGIMGFMT_TIFFRESUNIT_INCH == tiffInfo.resolutionUnit)
			{
				info->xDpi = (uint32_t)(tiffInfo.xResolution + 0.5f);
				info->yDpi = (uint32_t)(tiffInfo.yResolution + 0.5f);
			}
			else if (HGIMGFMT_TIFFRESUNIT_CENTIMETER == tiffInfo.resolutionUnit)
			{
				info->xDpi = (uint32_t)((double)tiffInfo.xResolution / 0.393700787 + 0.5);
				info->yDpi = (uint32_t)((double)tiffInfo.yResolution / 0.393700787 + 0.5);
			}
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_PDF == fmtType)
	{
		HGPdfPageInfo pdfInfo;
		HGResult ret = HGImgFmt_LoadPdfImage(fileName, &pdfInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = pdfInfo.width;
			info->height = pdfInfo.height;
			info->bpp = pdfInfo.bpp;
			info->xDpi = 0;
			info->yDpi = 0;
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_OFD == fmtType)
	{
		HGOfdPageInfo ofdInfo;
		HGResult ret = HGImgFmt_LoadOfdImage(fileName, &ofdInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = ofdInfo.width;
			info->height = ofdInfo.height;
			info->bpp = ofdInfo.bpp;
			info->xDpi = 0;
			info->yDpi = 0;
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_GIF == fmtType)
	{
		HGGifLoadInfo gifInfo;
		HGResult ret = HGImgFmt_LoadGifImage(fileName, &gifInfo, NULL, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = gifInfo.width;
			info->height = gifInfo.height;
			info->bpp = gifInfo.colorResolution;
			info->xDpi = 0;
			info->yDpi = 0;
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_PNM == fmtType)
	{
		HGPnmLoadInfo pnmInfo;
		HGResult ret = HGImgFmt_LoadPnmImage(fileName, &pnmInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = pnmInfo.width;
			info->height = pnmInfo.height;
			info->bpp = 1;
			if (pnmInfo.type == HGIMGFMT_PNMTYPE_GRAY_ASCII || pnmInfo.type == HGIMGFMT_PNMTYPE_GRAY_BINARY)
				info->bpp = 8;
			else if (pnmInfo.type == HGIMGFMT_PNMTYPE_RGB_ASCII || pnmInfo.type == HGIMGFMT_PNMTYPE_RGB_BINARY)
				info->bpp = 24;
			info->xDpi = 0;
			info->yDpi = 0;
		}

		return HGBASE_ERR_OK;
	}
    else if (HGIMGFMT_TYPE_TGA == fmtType)
    {
        return LoadTgaImage(fileName, info, imgType, imgOrigin, image);
    }
    else if (HGIMGFMT_TYPE_PCX == fmtType)
    {
        return LoadPcxImage(fileName, info, imgType, imgOrigin, image);
    }
    else if (HGIMGFMT_TYPE_RAS == fmtType)
    {
        return LoadRasImage(fileName, info, imgType, imgOrigin, image);
    }

	assert(0 == fmtType);

	HGJpegLoadInfo jpegInfo;
	HGResult ret = HGImgFmt_LoadJpegImage(fileName, &jpegInfo, imgType, imgOrigin, image);
	if (HGBASE_ERR_OK == ret)
	{
		if (NULL != info)
		{
			info->width = jpegInfo.width;
			info->height = jpegInfo.height;
			info->bpp = jpegInfo.numComponents * 8;
			info->xDpi = 0;
			info->yDpi = 0;
			if (HGIMGFMT_JPEGDENUNIT_INCH == jpegInfo.densityUnit)
			{
				info->xDpi = jpegInfo.xDensity;
				info->yDpi = jpegInfo.yDensity;
			}
			else if (HGIMGFMT_JPEGDENUNIT_CENTIMETER == jpegInfo.densityUnit)
			{
				info->xDpi = (uint32_t)((double)jpegInfo.xDensity / 0.393700787 + 0.5);
				info->yDpi = (uint32_t)((double)jpegInfo.yDensity / 0.393700787 + 0.5);
			}
		}

		return HGBASE_ERR_OK;
	}

	HGBmpLoadInfo bmpInfo;
	ret = HGImgFmt_LoadBmpImage(fileName, &bmpInfo, imgType, imgOrigin, image);
	if (HGBASE_ERR_OK == ret)
	{
		if (NULL != info)
		{
			info->width = bmpInfo.width;
			info->height = bmpInfo.height;
			info->bpp = bmpInfo.bitCount;
			info->xDpi = (uint32_t)((double)bmpInfo.xPelsPerMeter / 39.3700787 + 0.5);
			info->yDpi = (uint32_t)((double)bmpInfo.yPelsPerMeter / 39.3700787 + 0.5);
		}

		return HGBASE_ERR_OK;
	}

	HGPngLoadInfo pngInfo;
	ret = HGImgFmt_LoadPngImage(fileName, &pngInfo, imgType, imgOrigin, image);
	if (HGBASE_ERR_OK == ret)
	{
		if (NULL != info)
		{
			info->width = pngInfo.width;
			info->height = pngInfo.height;
			info->bpp = pngInfo.pixelDepth;
			info->xDpi = 0;
			info->yDpi = 0;
			if (HGIMGFMT_PNGPHYSUNIT_METER == pngInfo.physUnitType)
			{
				info->xDpi = (uint32_t)((double)pngInfo.xPixelsPerUnit / 39.3700787 + 0.5);
				info->yDpi = (uint32_t)((double)pngInfo.yPixelsPerUnit / 39.3700787 + 0.5);
			}
		}

		return HGBASE_ERR_OK;
	}

	HGTiffLoadInfo tiffInfo;
	ret = HGImgFmt_LoadTiffImage(fileName, &tiffInfo, imgType, imgOrigin, image);
	if (HGBASE_ERR_OK == ret)
	{
		if (NULL != info)
		{
			info->width = tiffInfo.width;
			info->height = tiffInfo.height;
			info->bpp = tiffInfo.bitsPerSample * tiffInfo.samplesPerPixel;
			info->xDpi = 0;
			info->yDpi = 0;
			if (HGIMGFMT_TIFFRESUNIT_INCH == tiffInfo.resolutionUnit)
			{
				info->xDpi = (uint32_t)(tiffInfo.xResolution + 0.5f);
				info->yDpi = (uint32_t)(tiffInfo.yResolution + 0.5f);
			}
			else if (HGIMGFMT_TIFFRESUNIT_CENTIMETER == tiffInfo.resolutionUnit)
			{
				info->xDpi = (uint32_t)((double)tiffInfo.xResolution / 0.393700787 + 0.5);
				info->yDpi = (uint32_t)((double)tiffInfo.yResolution / 0.393700787 + 0.5);
			}
		}

		return HGBASE_ERR_OK;
	}

	HGPdfPageInfo pdfInfo;
	ret = HGImgFmt_LoadPdfImage(fileName, &pdfInfo, imgType, imgOrigin, image);
	if (HGBASE_ERR_OK == ret)
	{
		if (NULL != info)
		{
			info->width = pdfInfo.width;
			info->height = pdfInfo.height;
			info->bpp = pdfInfo.bpp;
			info->xDpi = 0;
			info->yDpi = 0;
		}

		return HGBASE_ERR_OK;
	}

	HGOfdPageInfo ofdInfo;
	ret = HGImgFmt_LoadOfdImage(fileName, &ofdInfo, imgType, imgOrigin, image);
	if (HGBASE_ERR_OK == ret)
	{
		if (NULL != info)
		{
			info->width = ofdInfo.width;
			info->height = ofdInfo.height;
			info->bpp = ofdInfo.bpp;
			info->xDpi = 0;
			info->yDpi = 0;
		}

		return HGBASE_ERR_OK;
	}

	HGGifLoadInfo gifInfo;
	ret = HGImgFmt_LoadGifImage(fileName, &gifInfo, NULL, imgType, imgOrigin, image);
	if (HGBASE_ERR_OK == ret)
	{
		if (NULL != info)
		{
			info->width = gifInfo.width;
			info->height = gifInfo.height;
			info->bpp = gifInfo.colorResolution;
			info->xDpi = 0;
			info->yDpi = 0;
		}

		return HGBASE_ERR_OK;
	}

	HGPnmLoadInfo pnmInfo;
	ret = HGImgFmt_LoadPnmImage(fileName, &pnmInfo, imgType, imgOrigin, image);
	if (HGBASE_ERR_OK == ret)
	{
		if (NULL != info)
		{
			info->width = pnmInfo.width;
			info->height = pnmInfo.height;
			info->bpp = 1;
			if (pnmInfo.type == HGIMGFMT_PNMTYPE_GRAY_ASCII || pnmInfo.type == HGIMGFMT_PNMTYPE_GRAY_BINARY)
				info->bpp = 8;
			else if (pnmInfo.type == HGIMGFMT_PNMTYPE_RGB_ASCII || pnmInfo.type == HGIMGFMT_PNMTYPE_RGB_BINARY)
				info->bpp = 24;
			info->xDpi = 0;
			info->yDpi = 0;
		}

		return HGBASE_ERR_OK;
	}

    ret = LoadTgaImage(fileName, info, imgType, imgOrigin, image);
    if (HGBASE_ERR_OK == ret)
    {
        return HGBASE_ERR_OK;
    }

    ret = LoadPcxImage(fileName, info, imgType, imgOrigin, image);
    if (HGBASE_ERR_OK == ret)
    {
        return HGBASE_ERR_OK;
    }

    ret = LoadRasImage(fileName, info, imgType, imgOrigin, image);
    if (HGBASE_ERR_OK == ret)
    {
        return HGBASE_ERR_OK;
    }

	return ret;
}

HGResult HGAPI HGImgFmt_SaveImage(HGImage image, HGUInt fmtType, const HGImgFmtSaveInfo* info, const HGChar* fileName)
{
    if (fmtType > HGIMGFMT_TYPE_RAS)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (0 == fmtType)
	{
		HGImgFmt_GetImgFmtTypeFromFileName(fileName, &fmtType);
        if (fmtType < HGIMGFMT_TYPE_JPEG || fmtType > HGIMGFMT_TYPE_RAS)
		{
			return HGBASE_ERR_INVALIDARG;
		}
	}

	HGUInt xDpi = 0, yDpi = 0;
	HGBase_GetImageDpi(image, &xDpi, &yDpi);

	if (HGIMGFMT_TYPE_JPEG == fmtType)
	{
		HGJpegSaveInfo jpegInfo;
		HGJpegSaveInfo* pJpegInfo = NULL;

		if (NULL != info)
		{
			jpegInfo.quality = info->jpegQuality;
			jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
			jpegInfo.xDensity = xDpi;
			jpegInfo.yDensity = yDpi;
			pJpegInfo = &jpegInfo;
		}

		return HGImgFmt_SaveJpegImage(image, pJpegInfo, fileName);
	}
	else if (HGIMGFMT_TYPE_BMP == fmtType)
	{
		HGBmpSaveInfo bmpInfo;
		HGBmpSaveInfo* pBmpInfo = NULL;

		if (NULL != info)
		{
			bmpInfo.xPelsPerMeter = (uint32_t)((double)xDpi * 39.3700787 + 0.5);
			bmpInfo.yPelsPerMeter = (uint32_t)((double)yDpi * 39.3700787 + 0.5);
			pBmpInfo = &bmpInfo;
		}

		return HGImgFmt_SaveBmpImage(image, pBmpInfo, fileName);
	}
	else if (HGIMGFMT_TYPE_PNG == fmtType)
	{
		HGPngSaveInfo pngInfo;
		HGPngSaveInfo* pPngInfo = NULL;

		if (NULL != info)
		{
			pngInfo.physUnitType = HGIMGFMT_PNGPHYSUNIT_METER;
			pngInfo.xPixelsPerUnit = (uint32_t)((double)xDpi * 39.3700787 + 0.5);
			pngInfo.yPixelsPerUnit = (uint32_t)((double)yDpi * 39.3700787 + 0.5);
			pPngInfo = &pngInfo;
		}

		return HGImgFmt_SavePngImage(image, pPngInfo, fileName);
	}
	else if (HGIMGFMT_TYPE_TIFF == fmtType)
	{
		HGTiffSaveInfo tiffInfo;
		HGTiffSaveInfo* pTiffInfo = NULL;

		if (NULL != info)
		{
			tiffInfo.compression = info->tiffCompression;
			tiffInfo.jpegQuality = info->tiffJpegQuality;
			tiffInfo.resolutionUnit = HGIMGFMT_TIFFRESUNIT_INCH;
			tiffInfo.xResolution = (float)xDpi;
			tiffInfo.yResolution = (float)yDpi;
			pTiffInfo = &tiffInfo;
		}

		return HGImgFmt_SaveTiffImage(image, pTiffInfo, fileName);
	}
	else if (HGIMGFMT_TYPE_PDF == fmtType)
	{
		HGJpegSaveInfo jpegInfo;
		HGJpegSaveInfo* pJpegInfo = NULL;

		if (NULL != info)
		{
			jpegInfo.quality = info->jpegQuality;
			jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
			jpegInfo.xDensity = xDpi;
			jpegInfo.yDensity = yDpi;
			pJpegInfo = &jpegInfo;
		}

		return HGImgFmt_SavePdfJpegImage(image, pJpegInfo, fileName);
	}
	else if (HGIMGFMT_TYPE_OFD == fmtType)
	{
		HGJpegSaveInfo jpegInfo;
		HGJpegSaveInfo* pJpegInfo = NULL;

		if (NULL != info)
		{
			jpegInfo.quality = info->jpegQuality;
			jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
			jpegInfo.xDensity = xDpi;
			jpegInfo.yDensity = yDpi;
			pJpegInfo = &jpegInfo;
		}

		return HGImgFmt_SaveOfdJpegImage(image, pJpegInfo, fileName);
	}
	else if (HGIMGFMT_TYPE_GIF == fmtType)
	{
		return HGImgFmt_SaveGifImage(image, NULL, 50, HG_MAKECOLOR(255, 255, 255, 255), fileName);
	}
    else if (HGIMGFMT_TYPE_PNM == fmtType)
    {
        return HGImgFmt_SavePnmImage(image, NULL, fileName);
    }
    else if (HGIMGFMT_TYPE_TGA == fmtType)
    {
        return SaveTgaImage(image, NULL, fileName);
    }
    else if (HGIMGFMT_TYPE_PCX == fmtType)
    {
        return SavePcxImage(image, NULL, fileName);
    }

    assert(HGIMGFMT_TYPE_RAS == fmtType);

    return SaveRasImage(image, NULL, fileName);
}

HGResult HGAPI HGImgFmt_OpenImageReader(const HGChar* fileName, HGUInt fmtType, HGImgFmtReader* reader)
{
    if (NULL == fileName || fmtType > HGIMGFMT_TYPE_RAS || NULL == reader)
	{
		return HGBASE_ERR_INVALIDARG;
	}

    if (HGIMGFMT_TYPE_JPEG == fmtType || HGIMGFMT_TYPE_BMP == fmtType || HGIMGFMT_TYPE_PNG == fmtType
            || HGIMGFMT_TYPE_PNM == fmtType || HGIMGFMT_TYPE_TGA == fmtType || HGIMGFMT_TYPE_PCX == fmtType
            || HGIMGFMT_TYPE_RAS == fmtType)
	{
		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = fmtType;
		imgFmtReaderImpl->handle = NULL;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_TIFF == fmtType)
	{
		HGTiffReader tiffReader = NULL;
		HGResult ret = HGImgFmt_OpenTiffReader(fileName, &tiffReader);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = fmtType;
		imgFmtReaderImpl->handle = tiffReader;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_PDF == fmtType)
	{
		HGPdfReader pdfReader = NULL;
		HGResult ret = HGImgFmt_OpenPdfReader(fileName, &pdfReader);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = fmtType;
		imgFmtReaderImpl->handle = pdfReader;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_OFD == fmtType)
	{
		HGOfdReader ofdReader = NULL;
		HGResult ret = HGImgFmt_OpenOfdReader(fileName, &ofdReader);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = fmtType;
		imgFmtReaderImpl->handle = ofdReader;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_GIF == fmtType)
	{
		HGGifLoadInfo gifLoadInfo;
		HGGifReader gifReader = NULL;
		HGResult ret = HGImgFmt_OpenGifReader(fileName, &gifLoadInfo, &gifReader);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = fmtType;
		imgFmtReaderImpl->handle = gifReader;
		memcpy(&imgFmtReaderImpl->gifLoadInfo, &gifLoadInfo, sizeof(HGGifLoadInfo));
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}

	assert(0 == fmtType);

	HGBool isJpeg = HGFALSE;
	HGResult ret = HGImgFmt_CheckJpegFile(fileName, &isJpeg);
	if (isJpeg)
	{
		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_JPEG;
		imgFmtReaderImpl->handle = NULL;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}

	HGBool isBmp = HGFALSE;
	ret = HGImgFmt_CheckBmpFile(fileName, &isBmp);
	if (isBmp)
	{
		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_BMP;
		imgFmtReaderImpl->handle = NULL;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}

	HGBool isPng = HGFALSE;
	ret = HGImgFmt_CheckPngFile(fileName, &isPng);
	if (isPng)
	{
		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_PNG;
		imgFmtReaderImpl->handle = NULL;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}

	HGTiffReader tiffReader = NULL;
	ret = HGImgFmt_OpenTiffReader(fileName, &tiffReader);
	if (HGBASE_ERR_OK == ret)
	{
		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_TIFF;
		imgFmtReaderImpl->handle = tiffReader;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}

	HGPdfReader pdfReader = NULL;
	ret = HGImgFmt_OpenPdfReader(fileName, &pdfReader);
	if (HGBASE_ERR_OK == ret)
	{
		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_PDF;
		imgFmtReaderImpl->handle = pdfReader;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}

	HGOfdReader ofdReader = NULL;
	ret = HGImgFmt_OpenOfdReader(fileName, &ofdReader);
	if (HGBASE_ERR_OK == ret)
	{
		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_OFD;
		imgFmtReaderImpl->handle = ofdReader;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}

	HGGifLoadInfo gifLoadInfo;
	HGGifReader gifReader = NULL;
	ret = HGImgFmt_OpenGifReader(fileName, &gifLoadInfo, &gifReader);
	if (HGBASE_ERR_OK == ret)
	{
		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_GIF;
		imgFmtReaderImpl->handle = gifReader;
		memcpy(&imgFmtReaderImpl->gifLoadInfo, &gifLoadInfo, sizeof(HGGifLoadInfo));
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}

	HGBool isPnm = HGFALSE;
	ret = HGImgFmt_CheckPnmFile(fileName, &isPnm);
	if (isPnm)
	{
		HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
		imgFmtReaderImpl->fileName = fileName;
		imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_PNM;
		imgFmtReaderImpl->handle = NULL;
		*reader = (HGImgFmtReader)imgFmtReaderImpl;
		return HGBASE_ERR_OK;
	}

    HGBool isTga = HGFALSE;
    ret = CheckTgaFile(fileName, &isTga);
    if (isTga)
    {
        HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
        imgFmtReaderImpl->fileName = fileName;
        imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_TGA;
        imgFmtReaderImpl->handle = NULL;
        *reader = (HGImgFmtReader)imgFmtReaderImpl;
        return HGBASE_ERR_OK;
    }

    HGBool isPcx = HGFALSE;
    ret = CheckPcxFile(fileName, &isPcx);
    if (isPcx)
    {
        HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
        imgFmtReaderImpl->fileName = fileName;
        imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_PCX;
        imgFmtReaderImpl->handle = NULL;
        *reader = (HGImgFmtReader)imgFmtReaderImpl;
        return HGBASE_ERR_OK;
    }

    HGBool isRas = HGFALSE;
    ret = CheckRasFile(fileName, &isRas);
    if (isRas)
    {
        HGImgFmtReaderImpl* imgFmtReaderImpl = new HGImgFmtReaderImpl;
        imgFmtReaderImpl->fileName = fileName;
        imgFmtReaderImpl->fmtType = HGIMGFMT_TYPE_RAS;
        imgFmtReaderImpl->handle = NULL;
        *reader = (HGImgFmtReader)imgFmtReaderImpl;
        return HGBASE_ERR_OK;
    }

	return ret;
}

HGResult HGAPI HGImgFmt_CloseImageReader(HGImgFmtReader reader)
{
	if (NULL == reader)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGImgFmtReaderImpl* imgFmtReaderImpl = (HGImgFmtReaderImpl*)reader;
	if (HGIMGFMT_TYPE_TIFF == imgFmtReaderImpl->fmtType)
		HGImgFmt_CloseTiffReader((HGTiffReader)imgFmtReaderImpl->handle);
	else if (HGIMGFMT_TYPE_PDF == imgFmtReaderImpl->fmtType)
		HGImgFmt_ClosePdfReader((HGPdfReader)imgFmtReaderImpl->handle);
	else if (HGIMGFMT_TYPE_OFD == imgFmtReaderImpl->fmtType)
		HGImgFmt_CloseOfdReader((HGOfdReader)imgFmtReaderImpl->handle);
	else if (HGIMGFMT_TYPE_GIF == imgFmtReaderImpl->fmtType)
		HGImgFmt_CloseGifReader((HGGifReader)imgFmtReaderImpl->handle);

	delete imgFmtReaderImpl;
	return HGBASE_ERR_OK;
}

HGResult HGAPI HGImgFmt_GetImagePageCount(HGImgFmtReader reader, HGUInt* count)
{
	if (NULL == reader || NULL == count)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGImgFmtReaderImpl* imgFmtReaderImpl = (HGImgFmtReaderImpl*)reader;
	if (HGIMGFMT_TYPE_TIFF == imgFmtReaderImpl->fmtType)
		return HGImgFmt_GetTiffPageCount((HGTiffReader)imgFmtReaderImpl->handle, count);
	else if (HGIMGFMT_TYPE_PDF == imgFmtReaderImpl->fmtType)
		return HGImgFmt_GetPdfPageCount((HGPdfReader)imgFmtReaderImpl->handle, count);
	else if (HGIMGFMT_TYPE_OFD == imgFmtReaderImpl->fmtType)
		return HGImgFmt_GetOfdPageCount((HGOfdReader)imgFmtReaderImpl->handle, count);
	else if (HGIMGFMT_TYPE_GIF == imgFmtReaderImpl->fmtType)
	{
		*count = imgFmtReaderImpl->gifLoadInfo.imageCount;
		return HGBASE_ERR_OK;
	}

	*count = 1;
	return HGBASE_ERR_OK;
}

HGResult HGAPI HGImgFmt_LoadImageFromReader(HGImgFmtReader reader, HGUInt index, HGImgFmtLoadInfo* info, 
	HGUInt imgType, HGUInt imgOrigin, HGImage* image)
{
	if (NULL == reader)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGImgFmtReaderImpl* imgFmtReaderImpl = (HGImgFmtReaderImpl*)reader;
	if (HGIMGFMT_TYPE_JPEG == imgFmtReaderImpl->fmtType)
	{
		if (0 != index)
		{
			return HGBASE_ERR_INVALIDARG;
		}

		HGJpegLoadInfo jpegInfo;
		HGResult ret = HGImgFmt_LoadJpegImage(imgFmtReaderImpl->fileName.c_str(), &jpegInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = jpegInfo.width;
			info->height = jpegInfo.height;
			info->bpp = jpegInfo.numComponents * 8;
			info->xDpi = 0;
			info->yDpi = 0;
			if (HGIMGFMT_JPEGDENUNIT_INCH == jpegInfo.densityUnit)
			{
				info->xDpi = jpegInfo.xDensity;
				info->yDpi = jpegInfo.yDensity;
			}
			else if (HGIMGFMT_JPEGDENUNIT_CENTIMETER == jpegInfo.densityUnit)
			{
				info->xDpi = (uint32_t)((double)jpegInfo.xDensity / 0.393700787 + 0.5);
				info->yDpi = (uint32_t)((double)jpegInfo.yDensity / 0.393700787 + 0.5);
			}
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_BMP == imgFmtReaderImpl->fmtType)
	{
		if (0 != index)
		{
			return HGBASE_ERR_INVALIDARG;
		}

		HGBmpLoadInfo bmpInfo;
		HGResult ret = HGImgFmt_LoadBmpImage(imgFmtReaderImpl->fileName.c_str(), &bmpInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = bmpInfo.width;
			info->height = bmpInfo.height;
			info->bpp = bmpInfo.bitCount;
			info->xDpi = (uint32_t)((double)bmpInfo.xPelsPerMeter / 39.3700787 + 0.5);
			info->yDpi = (uint32_t)((double)bmpInfo.yPelsPerMeter / 39.3700787 + 0.5);
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_PNG == imgFmtReaderImpl->fmtType)
	{
		if (0 != index)
		{
			return HGBASE_ERR_INVALIDARG;
		}

		HGPngLoadInfo pngInfo;
		HGResult ret = HGImgFmt_LoadPngImage(imgFmtReaderImpl->fileName.c_str(), &pngInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = pngInfo.width;
			info->height = pngInfo.height;
			info->bpp = pngInfo.pixelDepth;
			info->xDpi = 0;
			info->yDpi = 0;
			if (HGIMGFMT_PNGPHYSUNIT_METER == pngInfo.physUnitType)
			{
				info->xDpi = (uint32_t)((double)pngInfo.xPixelsPerUnit / 39.3700787 + 0.5);
				info->yDpi = (uint32_t)((double)pngInfo.yPixelsPerUnit / 39.3700787 + 0.5);
			}
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_TIFF == imgFmtReaderImpl->fmtType)
	{
		HGTiffLoadInfo tiffInfo;
		HGResult ret = HGImgFmt_LoadImageFromTiffReader((HGTiffReader)imgFmtReaderImpl->handle, index, &tiffInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = tiffInfo.width;
			info->height = tiffInfo.height;
			info->bpp = tiffInfo.bitsPerSample * tiffInfo.samplesPerPixel;
			info->xDpi = 0;
			info->yDpi = 0;
			if (HGIMGFMT_TIFFRESUNIT_INCH == tiffInfo.resolutionUnit)
			{
				info->xDpi = (uint32_t)(tiffInfo.xResolution + 0.5f);
				info->yDpi = (uint32_t)(tiffInfo.yResolution + 0.5f);
			}
			else if (HGIMGFMT_TIFFRESUNIT_CENTIMETER == tiffInfo.resolutionUnit)
			{
				info->xDpi = (uint32_t)((double)tiffInfo.xResolution / 0.393700787 + 0.5);
				info->yDpi = (uint32_t)((double)tiffInfo.yResolution / 0.393700787 + 0.5);
			}
		}

		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_PDF == imgFmtReaderImpl->fmtType)
	{
		HGResult ret = HGBASE_ERR_OK;
		if (NULL != info)
		{
			info->width = 0;
			info->height = 0;
			info->bpp = 0;
			info->xDpi = 0;
			info->yDpi = 0;

			HGPdfPageInfo pdfInfo;
			ret = HGImgFmt_GetPdfPageInfo((HGPdfReader)imgFmtReaderImpl->handle, index, &pdfInfo);
			if (HGBASE_ERR_OK == ret)
			{
				info->width = pdfInfo.width;
				info->height = pdfInfo.height;
				info->bpp = pdfInfo.bpp;
			}
		}

		if (ret == HGBASE_ERR_OK && NULL != image)
		{
            ret = HGImgFmt_LoadImageFromPdfReader((HGPdfReader)imgFmtReaderImpl->handle, index, 300.0f / 72.0f, 300.0f / 72.0f, imgType, imgOrigin, image);
		}

		return ret;
	}
	else if (HGIMGFMT_TYPE_OFD == imgFmtReaderImpl->fmtType)
	{
		HGResult ret = HGBASE_ERR_OK;
		if (NULL != info)
		{
			info->width = 0;
			info->height = 0;
			info->bpp = 0;
			info->xDpi = 0;
			info->yDpi = 0;

			HGOfdPageInfo ofdInfo;
			ret = HGImgFmt_GetOfdPageInfo((HGOfdReader)imgFmtReaderImpl->handle, index, &ofdInfo);
			if (HGBASE_ERR_OK == ret)
			{
				info->width = ofdInfo.width;
				info->height = ofdInfo.height;
				info->bpp = ofdInfo.bpp;
			}
		}

		if (ret == HGBASE_ERR_OK && NULL != image)
		{
			ret = HGImgFmt_LoadImageFromOfdReader((HGOfdReader)imgFmtReaderImpl->handle, index, 1.0f, 1.0f, imgType, imgOrigin, image);
		}

		return ret;
	}
	else if (HGIMGFMT_TYPE_PNM == imgFmtReaderImpl->fmtType)
	{
		if (0 != index)
		{
			return HGBASE_ERR_INVALIDARG;
		}

		HGPnmLoadInfo pnmInfo;
		HGResult ret = HGImgFmt_LoadPnmImage(imgFmtReaderImpl->fileName.c_str(), &pnmInfo, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		if (NULL != info)
		{
			info->width = pnmInfo.width;
			info->height = pnmInfo.height;
			info->bpp = 1;
			if (pnmInfo.type == HGIMGFMT_PNMTYPE_GRAY_ASCII || pnmInfo.type == HGIMGFMT_PNMTYPE_GRAY_BINARY)
				info->bpp = 8;
			else if (pnmInfo.type == HGIMGFMT_PNMTYPE_RGB_ASCII || pnmInfo.type == HGIMGFMT_PNMTYPE_RGB_BINARY)
				info->bpp = 24;
			info->xDpi = 0;
			info->yDpi = 0;
		}

		return HGBASE_ERR_OK;
	}
    else if (HGIMGFMT_TYPE_TGA == imgFmtReaderImpl->fmtType)
    {
        if (0 != index)
        {
            return HGBASE_ERR_INVALIDARG;
        }

        return LoadTgaImage(imgFmtReaderImpl->fileName.c_str(), info, imgType, imgOrigin, image);
    }
    else if (HGIMGFMT_TYPE_PCX == imgFmtReaderImpl->fmtType)
    {
        if (0 != index)
        {
            return HGBASE_ERR_INVALIDARG;
        }

        return LoadPcxImage(imgFmtReaderImpl->fileName.c_str(), info, imgType, imgOrigin, image);
    }
    else if (HGIMGFMT_TYPE_RAS == imgFmtReaderImpl->fmtType)
    {
        if (0 != index)
        {
            return HGBASE_ERR_INVALIDARG;
        }

        return LoadRasImage(imgFmtReaderImpl->fileName.c_str(), info, imgType, imgOrigin, image);
    }

	assert(HGIMGFMT_TYPE_GIF == imgFmtReaderImpl->fmtType);

	if (NULL == image)
	{
		if (0 != imgType || 0 != imgOrigin)
		{
			return HGBASE_ERR_INVALIDARG;
		}
	}

	if (index >= imgFmtReaderImpl->gifLoadInfo.imageCount)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (NULL != info)
	{
		info->width = imgFmtReaderImpl->gifLoadInfo.width;
		info->height = imgFmtReaderImpl->gifLoadInfo.height;
		info->bpp = imgFmtReaderImpl->gifLoadInfo.colorResolution;
		info->xDpi = 0;
		info->yDpi = 0;
	}

	if (NULL != image)
	{
		HGResult ret = HGImgFmt_LoadImageFromGifReader((HGGifReader)imgFmtReaderImpl->handle, index, NULL, imgType, imgOrigin, image);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}
	}

	return HGBASE_ERR_OK;
}

HGResult HGAPI HGImgFmt_OpenImageWriter(const HGChar* fileName, HGUInt fmtType, HGImgFmtWriter* writer)
{
    if (fmtType > HGIMGFMT_TYPE_RAS || NULL == writer)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (0 == fmtType)
	{
		HGImgFmt_GetImgFmtTypeFromFileName(fileName, &fmtType);
        if (fmtType < HGIMGFMT_TYPE_JPEG || fmtType > HGIMGFMT_TYPE_RAS)
		{
			return HGBASE_ERR_INVALIDARG;
		}
	}

    if (HGIMGFMT_TYPE_JPEG == fmtType || HGIMGFMT_TYPE_BMP == fmtType || HGIMGFMT_TYPE_PNG == fmtType
            || HGIMGFMT_TYPE_PNM == fmtType || HGIMGFMT_TYPE_TGA == fmtType || HGIMGFMT_TYPE_PCX == fmtType
            || HGIMGFMT_TYPE_RAS == fmtType)
	{
		HGImgFmtWriterImpl* imgFmtWriterImpl = new HGImgFmtWriterImpl;
		imgFmtWriterImpl->fileName = fileName;
		imgFmtWriterImpl->fmtType = fmtType;
		imgFmtWriterImpl->handle = NULL;
		imgFmtWriterImpl->write = HGFALSE;
		*writer = (HGImgFmtWriter)imgFmtWriterImpl;
		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_TIFF == fmtType)
	{
		HGTiffWriter tiffWriter = NULL;
		HGResult ret = HGImgFmt_OpenTiffWriter(fileName, &tiffWriter);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		HGImgFmtWriterImpl* imgFmtWriterImpl = new HGImgFmtWriterImpl;
		imgFmtWriterImpl->fileName = fileName;
		imgFmtWriterImpl->fmtType = fmtType;
		imgFmtWriterImpl->handle = tiffWriter;
		imgFmtWriterImpl->write = HGFALSE;
		*writer = (HGImgFmtWriter)imgFmtWriterImpl;
		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_PDF == fmtType)
	{
		HGPdfImageWriter pdfWriter = NULL;
		HGResult ret = HGImgFmt_OpenPdfImageWriter(fileName, &pdfWriter);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		HGImgFmtWriterImpl* imgFmtWriterImpl = new HGImgFmtWriterImpl;
		imgFmtWriterImpl->fileName = fileName;
		imgFmtWriterImpl->fmtType = fmtType;
		imgFmtWriterImpl->handle = pdfWriter;
		imgFmtWriterImpl->write = HGFALSE;
		*writer = (HGImgFmtWriter)imgFmtWriterImpl;
		return HGBASE_ERR_OK;
	}
	else if (HGIMGFMT_TYPE_OFD == fmtType)
	{
		HGOfdImageWriter ofdWriter = NULL;
		HGResult ret = HGImgFmt_OpenOfdImageWriter(fileName, &ofdWriter);
		if (HGBASE_ERR_OK != ret)
		{
			return ret;
		}

		HGImgFmtWriterImpl* imgFmtWriterImpl = new HGImgFmtWriterImpl;
		imgFmtWriterImpl->fileName = fileName;
		imgFmtWriterImpl->fmtType = fmtType;
		imgFmtWriterImpl->handle = ofdWriter;
		imgFmtWriterImpl->write = HGFALSE;
		*writer = (HGImgFmtWriter)imgFmtWriterImpl;
		return HGBASE_ERR_OK;
	}

	assert(HGIMGFMT_TYPE_GIF == fmtType);

	HGGifWriter gifWriter = NULL;
	HGResult ret = HGImgFmt_OpenGifWriter(fileName, NULL, &gifWriter);
	if (HGBASE_ERR_OK != ret)
	{
		return ret;
	}

	HGImgFmtWriterImpl* imgFmtWriterImpl = new HGImgFmtWriterImpl;
	imgFmtWriterImpl->fileName = fileName;
	imgFmtWriterImpl->fmtType = fmtType;
	imgFmtWriterImpl->handle = gifWriter;
	imgFmtWriterImpl->write = HGFALSE;
	*writer = (HGImgFmtWriter)imgFmtWriterImpl;
	return HGBASE_ERR_OK;
}

HGResult HGAPI HGImgFmt_CloseImageWriter(HGImgFmtWriter writer)
{
	if (NULL == writer)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGImgFmtWriterImpl* imgFmtWriterImpl = (HGImgFmtWriterImpl*)writer;
	if (HGIMGFMT_TYPE_TIFF == imgFmtWriterImpl->fmtType)
		HGImgFmt_CloseTiffWriter((HGTiffWriter)imgFmtWriterImpl->handle);
	else if (HGIMGFMT_TYPE_PDF == imgFmtWriterImpl->fmtType)
		HGImgFmt_ClosePdfImageWriter((HGPdfImageWriter)imgFmtWriterImpl->handle);
	else if (HGIMGFMT_TYPE_OFD == imgFmtWriterImpl->fmtType)
		HGImgFmt_CloseOfdImageWriter((HGOfdImageWriter)imgFmtWriterImpl->handle);
	else if (HGIMGFMT_TYPE_GIF == imgFmtWriterImpl->fmtType)
		HGImgFmt_CloseGifWriter((HGGifWriter)imgFmtWriterImpl->handle);

	delete imgFmtWriterImpl;
	return HGBASE_ERR_OK;
}

HGResult HGAPI HGImgFmt_SaveImageToWriter(HGImgFmtWriter writer, HGImage image, const HGImgFmtSaveInfo* info)
{
	if (NULL == writer)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt xDpi = 0, yDpi = 0;
	HGBase_GetImageDpi(image, &xDpi, &yDpi);

	HGImgFmtWriterImpl* imgFmtWriterImpl = (HGImgFmtWriterImpl*)writer;
	if (HGIMGFMT_TYPE_JPEG == imgFmtWriterImpl->fmtType)
	{
		if (imgFmtWriterImpl->write)
		{
			return HGBASE_ERR_FAIL;
		}

		HGJpegSaveInfo jpegInfo;
		HGJpegSaveInfo* pJpegInfo = NULL;

		if (NULL != info)
		{
			jpegInfo.quality = info->jpegQuality;
			jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
			jpegInfo.xDensity = xDpi;
			jpegInfo.yDensity = yDpi;
			pJpegInfo = &jpegInfo;
		}

		HGResult ret = HGImgFmt_SaveJpegImage(image, pJpegInfo, imgFmtWriterImpl->fileName.c_str());
		if (HGBASE_ERR_OK == ret)
		{
			imgFmtWriterImpl->write = HGTRUE;
		}

		return ret;
	}
	else if (HGIMGFMT_TYPE_BMP == imgFmtWriterImpl->fmtType)
	{
		if (imgFmtWriterImpl->write)
		{
			return HGBASE_ERR_FAIL;
		}

		HGBmpSaveInfo bmpInfo;
		HGBmpSaveInfo* pBmpInfo = NULL;

		if (NULL != info)
		{
			bmpInfo.xPelsPerMeter = (uint32_t)((double)xDpi * 39.3700787 + 0.5);
			bmpInfo.yPelsPerMeter = (uint32_t)((double)yDpi * 39.3700787 + 0.5);
			pBmpInfo = &bmpInfo;
		}

		HGResult ret = HGImgFmt_SaveBmpImage(image, pBmpInfo, imgFmtWriterImpl->fileName.c_str());
		if (HGBASE_ERR_OK == ret)
		{
			imgFmtWriterImpl->write = HGTRUE;
		}

		return ret;
	}
	else if (HGIMGFMT_TYPE_PNG == imgFmtWriterImpl->fmtType)
	{
		if (imgFmtWriterImpl->write)
		{
			return HGBASE_ERR_FAIL;
		}

		HGPngSaveInfo pngInfo;
		HGPngSaveInfo* pPngInfo = NULL;

		if (NULL != info)
		{
			pngInfo.physUnitType = HGIMGFMT_PNGPHYSUNIT_METER;
			pngInfo.xPixelsPerUnit = (uint32_t)((double)xDpi * 39.3700787 + 0.5);
			pngInfo.yPixelsPerUnit = (uint32_t)((double)yDpi * 39.3700787 + 0.5);
			pPngInfo = &pngInfo;
		}

		HGResult ret = HGImgFmt_SavePngImage(image, pPngInfo, imgFmtWriterImpl->fileName.c_str());
		if (HGBASE_ERR_OK == ret)
		{
			imgFmtWriterImpl->write = HGTRUE;
		}

		return ret;
	}
	else if (HGIMGFMT_TYPE_TIFF == imgFmtWriterImpl->fmtType)
	{
		HGTiffSaveInfo tiffInfo;
		HGTiffSaveInfo* pTiffInfo = NULL;

		if (NULL != info)
		{
			tiffInfo.compression = info->tiffCompression;
			tiffInfo.jpegQuality = info->tiffJpegQuality;
			tiffInfo.resolutionUnit = HGIMGFMT_TIFFRESUNIT_INCH;
			tiffInfo.xResolution = (float)xDpi;
			tiffInfo.yResolution = (float)yDpi;
			pTiffInfo = &tiffInfo;
		}

		return HGImgFmt_SaveImageToTiffWriter((HGTiffWriter)imgFmtWriterImpl->handle, image, pTiffInfo);
	}
	else if (HGIMGFMT_TYPE_PDF == imgFmtWriterImpl->fmtType)
	{
		HGJpegSaveInfo jpegInfo;
		HGJpegSaveInfo* pJpegInfo = NULL;

		if (NULL != info)
		{
			jpegInfo.quality = info->jpegQuality;
			jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
			jpegInfo.xDensity = xDpi;
			jpegInfo.yDensity = yDpi;
			pJpegInfo = &jpegInfo;
		}

		return HGImgFmt_SaveJpegImageToPdfImageWriter((HGPdfImageWriter)imgFmtWriterImpl->handle, image, pJpegInfo);
	}
	else if (HGIMGFMT_TYPE_OFD == imgFmtWriterImpl->fmtType)
	{
		HGJpegSaveInfo jpegInfo;
		HGJpegSaveInfo* pJpegInfo = NULL;

		if (NULL != info)
		{
			jpegInfo.quality = info->jpegQuality;
			jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
			jpegInfo.xDensity = xDpi;
			jpegInfo.yDensity = yDpi;
			pJpegInfo = &jpegInfo;
		}

		return HGImgFmt_SaveJpegImageToOfdImageWriter((HGOfdImageWriter)imgFmtWriterImpl->handle, image, pJpegInfo);
	}
	else if (HGIMGFMT_TYPE_PNM == imgFmtWriterImpl->fmtType)
	{
		if (imgFmtWriterImpl->write)
		{
			return HGBASE_ERR_FAIL;
		}

		HGResult ret = HGImgFmt_SavePnmImage(image, NULL, imgFmtWriterImpl->fileName.c_str());
		if (HGBASE_ERR_OK == ret)
		{
			imgFmtWriterImpl->write = HGTRUE;
		}

		return ret;
	}
    else if (HGIMGFMT_TYPE_TGA == imgFmtWriterImpl->fmtType)
    {
        if (imgFmtWriterImpl->write)
        {
            return HGBASE_ERR_FAIL;
        }

        HGResult ret = SaveTgaImage(image, NULL, imgFmtWriterImpl->fileName.c_str());
        if (HGBASE_ERR_OK == ret)
        {
            imgFmtWriterImpl->write = HGTRUE;
        }

        return ret;
    }
    else if (HGIMGFMT_TYPE_PCX == imgFmtWriterImpl->fmtType)
    {
        if (imgFmtWriterImpl->write)
        {
            return HGBASE_ERR_FAIL;
        }

        HGResult ret = SavePcxImage(image, NULL, imgFmtWriterImpl->fileName.c_str());
        if (HGBASE_ERR_OK == ret)
        {
            imgFmtWriterImpl->write = HGTRUE;
        }

        return ret;
    }
    else if (HGIMGFMT_TYPE_RAS == imgFmtWriterImpl->fmtType)
    {
        if (imgFmtWriterImpl->write)
        {
            return HGBASE_ERR_FAIL;
        }

        HGResult ret = SaveRasImage(image, NULL, imgFmtWriterImpl->fileName.c_str());
        if (HGBASE_ERR_OK == ret)
        {
            imgFmtWriterImpl->write = HGTRUE;
        }

        return ret;
    }

	assert(HGIMGFMT_TYPE_GIF == imgFmtWriterImpl->fmtType);

	return HGImgFmt_SaveImageToGifWriter((HGGifWriter)imgFmtWriterImpl->handle, 50, HG_MAKECOLOR(255, 255, 255, 255), image);
}