1226 lines
30 KiB
C++
1226 lines
30 KiB
C++
#include "HGImgFmt.h"
|
|
#include "HGJpeg.h"
|
|
#include "HGBmp.h"
|
|
#include "HGPng.h"
|
|
#include "HGTiff.h"
|
|
#include "HGPdf.h"
|
|
#include "HGOfd.h"
|
|
#include "../base/HGInc.h"
|
|
#include <string>
|
|
|
|
struct HGImgFmtReaderImpl
|
|
{
|
|
HGImgFmtReaderImpl()
|
|
{
|
|
fmtType = 0;
|
|
handle = NULL;
|
|
}
|
|
|
|
std::string fileName;
|
|
HGUInt fmtType;
|
|
HGPointer handle;
|
|
};
|
|
|
|
struct HGImgFmtWriterImpl
|
|
{
|
|
HGImgFmtWriterImpl()
|
|
{
|
|
fmtType = 0;
|
|
handle = NULL;
|
|
write = HGFALSE;
|
|
}
|
|
|
|
std::string fileName;
|
|
HGUInt fmtType;
|
|
HGPointer handle;
|
|
HGBool write; // 用于标记JPEG、BMP和PNG是否已经写入
|
|
};
|
|
|
|
HGResult HGAPI HGImgFmt_GetImgFmtType(const HGChar* fileName, HGUInt* fmtType)
|
|
{
|
|
if (NULL == fileName || NULL == fmtType)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
HGBool isJpeg = HGFALSE;
|
|
HGImgFmt_CheckJpegFile(fileName, &isJpeg);
|
|
if (isJpeg)
|
|
{
|
|
*fmtType = HGIMGFMT_TYPE_JPEG;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGBool isBmp = HGFALSE;
|
|
HGImgFmt_CheckBmpFile(fileName, &isBmp);
|
|
if (isBmp)
|
|
{
|
|
*fmtType = HGIMGFMT_TYPE_BMP;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGBool isPng = HGFALSE;
|
|
HGImgFmt_CheckPngFile(fileName, &isPng);
|
|
if (isPng)
|
|
{
|
|
*fmtType = HGIMGFMT_TYPE_PNG;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGBool isTiff = HGFALSE;
|
|
HGImgFmt_CheckTiffFile(fileName, &isTiff);
|
|
if (isTiff)
|
|
{
|
|
*fmtType = HGIMGFMT_TYPE_TIFF;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGBool isPdf = HGFALSE;
|
|
HGImgFmt_CheckPdfFile(fileName, &isPdf);
|
|
if (isPdf)
|
|
{
|
|
*fmtType = HGIMGFMT_TYPE_PDF;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGBool isOfd = HGFALSE;
|
|
HGImgFmt_CheckOfdFile(fileName, &isOfd);
|
|
if (isOfd)
|
|
{
|
|
*fmtType = HGIMGFMT_TYPE_OFD;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
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_FAIL;
|
|
}
|
|
|
|
#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;
|
|
}
|
|
#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;
|
|
}
|
|
#endif
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGResult HGAPI HGImgFmt_IsMultiImgFmtType(HGUInt fmtType, HGBool* isMulti)
|
|
{
|
|
if (fmtType < HGIMGFMT_TYPE_JPEG || fmtType > HGIMGFMT_TYPE_OFD || NULL == isMulti)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
if (HGIMGFMT_TYPE_JPEG == fmtType || HGIMGFMT_TYPE_BMP == fmtType || HGIMGFMT_TYPE_PNG == 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_OFD)
|
|
{
|
|
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)
|
|
{
|
|
HGTiffReader tiffReader = NULL;
|
|
HGResult ret = HGImgFmt_OpenTiffReader(fileName, &tiffReader);
|
|
if (HGBASE_ERR_OK != ret)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
UPTiffLoadInfo tiffInfo;
|
|
ret = HGImgFmt_LoadImageFromTiffReader(tiffReader, 0, &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);
|
|
}
|
|
}
|
|
}
|
|
|
|
HGImgFmt_CloseTiffReader(tiffReader);
|
|
return ret;
|
|
}
|
|
else if (HGIMGFMT_TYPE_PDF == fmtType)
|
|
{
|
|
HGPdfReader pdfReader = NULL;
|
|
HGResult ret = HGImgFmt_OpenPdfReader(fileName, &pdfReader);
|
|
if (HGBASE_ERR_OK != ret)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
ret = HGImgFmt_LoadImageFromPdfReader(pdfReader, 0, 1.0f, 1.0f, imgType, imgOrigin, image);
|
|
if (HGBASE_ERR_OK == ret)
|
|
{
|
|
if (NULL != info)
|
|
{
|
|
info->width = 0;
|
|
info->height = 0;
|
|
info->bpp = 0;
|
|
info->xDpi = 0;
|
|
info->yDpi = 0;
|
|
}
|
|
}
|
|
|
|
HGImgFmt_ClosePdfReader(pdfReader);
|
|
return ret;
|
|
}
|
|
else if (HGIMGFMT_TYPE_OFD == fmtType)
|
|
{
|
|
HGOfdReader ofdReader = NULL;
|
|
HGResult ret = HGImgFmt_OpenOfdReader(fileName, &ofdReader);
|
|
if (HGBASE_ERR_OK != ret)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
ret = HGImgFmt_LoadImageFromOfdReader(ofdReader, 0, 1.0f, 1.0f, imgType, imgOrigin, image);
|
|
if (HGBASE_ERR_OK == ret)
|
|
{
|
|
if (NULL != info)
|
|
{
|
|
info->width = 0;
|
|
info->height = 0;
|
|
info->bpp = 0;
|
|
info->xDpi = 0;
|
|
info->yDpi = 0;
|
|
}
|
|
}
|
|
|
|
HGImgFmt_CloseOfdReader(ofdReader);
|
|
return ret;
|
|
}
|
|
|
|
assert(0 == fmtType);
|
|
|
|
HGJpegLoadInfo jpegInfo;
|
|
if (HGBASE_ERR_OK == HGImgFmt_LoadJpegImage(fileName, &jpegInfo, imgType, imgOrigin, image))
|
|
{
|
|
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;
|
|
if (HGBASE_ERR_OK == HGImgFmt_LoadBmpImage(fileName, &bmpInfo, imgType, imgOrigin, image))
|
|
{
|
|
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;
|
|
if (HGBASE_ERR_OK == HGImgFmt_LoadPngImage(fileName, &pngInfo, imgType, imgOrigin, image))
|
|
{
|
|
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;
|
|
}
|
|
|
|
HGTiffReader tiffReader = NULL;
|
|
HGImgFmt_OpenTiffReader(fileName, &tiffReader);
|
|
if (NULL != tiffReader)
|
|
{
|
|
UPTiffLoadInfo tiffInfo;
|
|
if (HGBASE_ERR_OK == HGImgFmt_LoadImageFromTiffReader(tiffReader, 0, &tiffInfo, imgType, imgOrigin, image))
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
HGImgFmt_CloseTiffReader(tiffReader);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGImgFmt_CloseTiffReader(tiffReader);
|
|
}
|
|
|
|
HGPdfReader pdfReader = NULL;
|
|
HGImgFmt_OpenPdfReader(fileName, &pdfReader);
|
|
if (NULL != pdfReader)
|
|
{
|
|
if (HGBASE_ERR_OK == HGImgFmt_LoadImageFromPdfReader(pdfReader, 0, 1.0f, 1.0f, imgType, imgOrigin, image))
|
|
{
|
|
if (NULL != info)
|
|
{
|
|
info->width = 0;
|
|
info->height = 0;
|
|
info->bpp = 0;
|
|
info->xDpi = 0;
|
|
info->yDpi = 0;
|
|
}
|
|
|
|
HGImgFmt_ClosePdfReader(pdfReader);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGImgFmt_ClosePdfReader(pdfReader);
|
|
}
|
|
|
|
HGOfdReader ofdReader = NULL;
|
|
HGImgFmt_OpenOfdReader(fileName, &ofdReader);
|
|
if (NULL != ofdReader)
|
|
{
|
|
if (HGBASE_ERR_OK == HGImgFmt_LoadImageFromOfdReader(ofdReader, 0, 1.0f, 1.0f, imgType, imgOrigin, image))
|
|
{
|
|
if (NULL != info)
|
|
{
|
|
info->width = 0;
|
|
info->height = 0;
|
|
info->bpp = 0;
|
|
info->xDpi = 0;
|
|
info->yDpi = 0;
|
|
}
|
|
|
|
HGImgFmt_CloseOfdReader(ofdReader);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGImgFmt_CloseOfdReader(ofdReader);
|
|
}
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGResult HGAPI HGImgFmt_SaveImage(HGImage image, HGUInt fmtType, const HGImgFmtSaveInfo* info, const HGChar* fileName)
|
|
{
|
|
if (fmtType > HGIMGFMT_TYPE_OFD)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
if (0 == fmtType)
|
|
{
|
|
HGImgFmt_GetImgFmtTypeFromFileName(fileName, &fmtType);
|
|
if (fmtType < HGIMGFMT_TYPE_JPEG || fmtType > HGIMGFMT_TYPE_OFD)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
}
|
|
|
|
if (HGIMGFMT_TYPE_JPEG == fmtType)
|
|
{
|
|
HGJpegSaveInfo jpegInfo;
|
|
HGJpegSaveInfo* pJpegInfo = NULL;
|
|
|
|
if (NULL != info)
|
|
{
|
|
jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
|
|
jpegInfo.xDensity = info->xDpi;
|
|
jpegInfo.yDensity = info->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)info->xDpi * 39.3700787 + 0.5);
|
|
bmpInfo.yPelsPerMeter = (uint32_t)((double)info->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)info->xDpi * 39.3700787 + 0.5);
|
|
pngInfo.yPixelsPerUnit = (uint32_t)((double)info->yDpi * 39.3700787 + 0.5);
|
|
pPngInfo = &pngInfo;
|
|
}
|
|
|
|
return HGImgFmt_SavePngImage(image, pPngInfo, fileName);
|
|
}
|
|
else if (HGIMGFMT_TYPE_TIFF == fmtType)
|
|
{
|
|
HGTiffWriter tiffWriter = NULL;
|
|
HGResult ret = HGImgFmt_OpenTiffWriter(fileName, &tiffWriter);
|
|
if (HGBASE_ERR_OK != ret)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
UPTiffSaveInfo tiffInfo;
|
|
UPTiffSaveInfo* pTiffInfo = NULL;
|
|
|
|
if (NULL != info)
|
|
{
|
|
tiffInfo.resolutionUnit = HGIMGFMT_TIFFRESUNIT_INCH;
|
|
tiffInfo.xResolution = (float)info->xDpi;
|
|
tiffInfo.yResolution = (float)info->yDpi;
|
|
pTiffInfo = &tiffInfo;
|
|
}
|
|
|
|
ret = HGImgFmt_SaveImageToTiffWriter(tiffWriter, image, pTiffInfo);
|
|
HGImgFmt_CloseTiffWriter(tiffWriter);
|
|
return ret;
|
|
}
|
|
else if (HGIMGFMT_TYPE_PDF == fmtType)
|
|
{
|
|
HGPdfImageWriter pdfImgWriter = NULL;
|
|
HGResult ret = HGImgFmt_OpenPdfImageWriter(fileName, &pdfImgWriter);
|
|
if (HGBASE_ERR_OK != ret)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
HGJpegSaveInfo jpegInfo;
|
|
HGJpegSaveInfo* pJpegInfo = NULL;
|
|
|
|
if (NULL != info)
|
|
{
|
|
jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
|
|
jpegInfo.xDensity = info->xDpi;
|
|
jpegInfo.yDensity = info->yDpi;
|
|
pJpegInfo = &jpegInfo;
|
|
}
|
|
|
|
ret = HGImgFmt_SaveJpegImageToPdfImageWriter(pdfImgWriter, image, pJpegInfo);
|
|
HGImgFmt_ClosePdfImageWriter(pdfImgWriter);
|
|
return ret;
|
|
}
|
|
|
|
assert(HGIMGFMT_TYPE_OFD == fmtType);
|
|
|
|
HGOfdImageWriter ofdImgWriter = NULL;
|
|
HGResult ret = HGImgFmt_OpenOfdImageWriter(fileName, &ofdImgWriter);
|
|
if (HGBASE_ERR_OK != ret)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
HGJpegSaveInfo jpegInfo;
|
|
HGJpegSaveInfo* pJpegInfo = NULL;
|
|
|
|
if (NULL != info)
|
|
{
|
|
jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
|
|
jpegInfo.xDensity = info->xDpi;
|
|
jpegInfo.yDensity = info->yDpi;
|
|
pJpegInfo = &jpegInfo;
|
|
}
|
|
|
|
ret = HGImgFmt_SaveJpegImageToOfdImageWriter(ofdImgWriter, image, pJpegInfo);
|
|
HGImgFmt_CloseOfdImageWriter(ofdImgWriter);
|
|
return ret;
|
|
}
|
|
|
|
HGResult HGAPI HGImgFmt_OpenImageReader(const HGChar* fileName, HGUInt fmtType, HGImgFmtReader* reader)
|
|
{
|
|
if (NULL == fileName || fmtType > HGIMGFMT_TYPE_OFD || NULL == reader)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
if (HGIMGFMT_TYPE_JPEG == fmtType || HGIMGFMT_TYPE_BMP == fmtType
|
|
|| HGIMGFMT_TYPE_PNG == 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;
|
|
}
|
|
|
|
assert(0 == fmtType);
|
|
|
|
HGBool isJpeg = HGFALSE;
|
|
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;
|
|
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;
|
|
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;
|
|
HGResult 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;
|
|
}
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
*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)
|
|
{
|
|
UPTiffLoadInfo 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 = HGImgFmt_LoadImageFromPdfReader((HGPdfReader)imgFmtReaderImpl->handle, index, 1.0f, 1.0f, imgType, imgOrigin, image);
|
|
if (HGBASE_ERR_OK != ret)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
if (NULL != info)
|
|
{
|
|
info->width = 0;
|
|
info->height = 0;
|
|
info->bpp = 0;
|
|
info->xDpi = 0;
|
|
info->yDpi = 0;
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
assert(HGIMGFMT_TYPE_OFD == imgFmtReaderImpl->fmtType);
|
|
|
|
HGResult ret = HGImgFmt_LoadImageFromOfdReader((HGOfdReader)imgFmtReaderImpl->handle, index, 1.0f, 1.0f, imgType, imgOrigin, image);
|
|
if (HGBASE_ERR_OK != ret)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
if (NULL != info)
|
|
{
|
|
info->width = 0;
|
|
info->height = 0;
|
|
info->bpp = 0;
|
|
info->xDpi = 0;
|
|
info->yDpi = 0;
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGAPI HGImgFmt_OpenImageWriter(const HGChar* fileName, HGUInt fmtType, HGImgFmtWriter* writer)
|
|
{
|
|
if (fmtType > HGIMGFMT_TYPE_OFD || NULL == writer)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
if (0 == fmtType)
|
|
{
|
|
HGImgFmt_GetImgFmtTypeFromFileName(fileName, &fmtType);
|
|
if (fmtType < HGIMGFMT_TYPE_JPEG || fmtType > HGIMGFMT_TYPE_OFD)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
}
|
|
|
|
if (HGIMGFMT_TYPE_JPEG == fmtType || HGIMGFMT_TYPE_BMP == fmtType
|
|
|| HGIMGFMT_TYPE_PNG == 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;
|
|
}
|
|
|
|
assert(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;
|
|
}
|
|
|
|
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);
|
|
|
|
delete imgFmtWriterImpl;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGAPI HGImgFmt_SaveImageToWriter(HGImgFmtWriter writer, HGImage image, const HGImgFmtSaveInfo* info)
|
|
{
|
|
if (NULL == writer)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
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.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
|
|
jpegInfo.xDensity = info->xDpi;
|
|
jpegInfo.yDensity = info->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)info->xDpi * 39.3700787 + 0.5);
|
|
bmpInfo.yPelsPerMeter = (uint32_t)((double)info->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)info->xDpi * 39.3700787 + 0.5);
|
|
pngInfo.yPixelsPerUnit = (uint32_t)((double)info->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)
|
|
{
|
|
UPTiffSaveInfo tiffInfo;
|
|
UPTiffSaveInfo* pTiffInfo = NULL;
|
|
|
|
if (NULL != info)
|
|
{
|
|
tiffInfo.resolutionUnit = HGIMGFMT_TIFFRESUNIT_INCH;
|
|
tiffInfo.xResolution = (float)info->xDpi;
|
|
tiffInfo.yResolution = (float)info->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.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
|
|
jpegInfo.xDensity = info->xDpi;
|
|
jpegInfo.yDensity = info->yDpi;
|
|
pJpegInfo = &jpegInfo;
|
|
}
|
|
|
|
return HGImgFmt_SaveJpegImageToPdfImageWriter((HGPdfImageWriter)imgFmtWriterImpl->handle, image, pJpegInfo);
|
|
}
|
|
|
|
assert(HGIMGFMT_TYPE_OFD == imgFmtWriterImpl->fmtType);
|
|
|
|
HGJpegSaveInfo jpegInfo;
|
|
HGJpegSaveInfo* pJpegInfo = NULL;
|
|
|
|
if (NULL != info)
|
|
{
|
|
jpegInfo.densityUnit = HGIMGFMT_JPEGDENUNIT_INCH;
|
|
jpegInfo.xDensity = info->xDpi;
|
|
jpegInfo.yDensity = info->yDpi;
|
|
pJpegInfo = &jpegInfo;
|
|
}
|
|
|
|
return HGImgFmt_SaveJpegImageToOfdImageWriter((HGOfdImageWriter)imgFmtWriterImpl->handle, image, pJpegInfo);
|
|
} |