|
|
#include "precomp.h"
#include "gphelper.h"
#include "psutil.h"
using namespace Gdiplus;
CGdiPlusHelper::CGdiPlusHelper(void) : m_pImageEncoderInfo(NULL), m_nImageEncoderCount(0), m_pImageDecoderInfo(NULL), m_nImageDecoderCount(0)#if defined(GDIPLUSHELPER_EXPLICIT_INITIALIZATION)
,m_bGdiplusInitialized(false) ,m_pGdiplusToken(NULL)#endif
{ Initialize();}
CGdiPlusHelper::~CGdiPlusHelper(void){ Destroy();}
HRESULT CGdiPlusHelper::Initialize(void){#if defined(GDIPLUSHELPER_EXPLICIT_INITIALIZATION)
// Make sure GDI+ is initialized
Gdiplus::GdiplusStartupInput StartupInput; m_bGdiplusInitialized = (Gdiplus::GdiplusStartup(&m_pGdiplusToken,&StartupInput,NULL) == Gdiplus::Ok);#endif
// Get the installed encoders
HRESULT hr = E_FAIL; UINT cbCodecs = 0; GetImageEncodersSize( &m_nImageEncoderCount, &cbCodecs ); if (cbCodecs) { m_pImageEncoderInfo = static_cast<ImageCodecInfo*>(LocalAlloc(LPTR,cbCodecs)); if (m_pImageEncoderInfo) { GpStatus Status = GetImageEncoders( m_nImageEncoderCount, cbCodecs, m_pImageEncoderInfo ); if (Ok == Status) { for (UINT i=0;i<m_nImageEncoderCount;i++) { ////WIA_PRINTGUID((m_pImageEncoderInfo[i].Clsid,TEXT("m_pImageEncoderInfo[i].Clsid")));
////WIA_PRINTGUID((m_pImageEncoderInfo[i].FormatID,TEXT("m_pImageEncoderInfo[i].FormatID")));
} hr = S_OK; } } }
// Get the installed decoders
cbCodecs = 0; GetImageDecodersSize( &m_nImageDecoderCount, &cbCodecs ); if (cbCodecs) { m_pImageDecoderInfo = static_cast<ImageCodecInfo*>(LocalAlloc(LPTR,cbCodecs)); if (m_pImageDecoderInfo) { GpStatus Status = GetImageDecoders( m_nImageDecoderCount, cbCodecs, m_pImageDecoderInfo ); if (Ok == Status) { hr = S_OK; } } } // If there was a problem, make sure there are no half-initialized things laying around
if (FAILED(hr)) { Destroy(); } return hr;}
void CGdiPlusHelper::Destroy(void){
#if defined(GDIPLUSHELPER_EXPLICIT_INITIALIZATION)
// Shut down GDI+
if (m_bGdiplusInitialized) { Gdiplus::GdiplusShutdown(m_pGdiplusToken); m_bGdiplusInitialized = false; m_pGdiplusToken = NULL; }#endif
// Free the lists of Encoders and Decoders
if (m_pImageEncoderInfo) { LocalFree(m_pImageEncoderInfo); m_pImageEncoderInfo = NULL; } m_nImageEncoderCount = 0;
if (m_pImageDecoderInfo) { LocalFree(m_pImageDecoderInfo); m_pImageDecoderInfo = NULL; } m_nImageDecoderCount = 0;}
bool CGdiPlusHelper::IsValid(void) const{ // Make sure we've been completely created
#if defined(GDIPLUSHELPER_EXPLICIT_INITIALIZATION)
return(m_bGdiplusInitialized && m_pImageEncoderInfo && m_nImageEncoderCount && m_pImageDecoderInfo && m_nImageDecoderCount);#else
return(m_pImageEncoderInfo && m_nImageEncoderCount && m_pImageDecoderInfo && m_nImageDecoderCount);#endif
}
HRESULT CGdiPlusHelper::LoadAndScale( HBITMAP &hTargetBitmap, LPCTSTR pszFilename, UINT nMaxWidth, UINT nMaxHeight, bool bStretchSmallImages ){ hTargetBitmap = NULL; // Make sure we have a valid filename
if (pszFilename && lstrlen(pszFilename)) { Bitmap SourceBitmap( CSimpleStringConvert::WideString(CSimpleString(pszFilename) ) ); if (Ok == SourceBitmap.GetLastStatus()) { // Get the image width and height
UINT nSourceWidth = SourceBitmap.GetWidth(); UINT nSourceHeight = SourceBitmap.GetHeight();
// Make sure the width and height are non-zero
if (nSourceWidth && nSourceHeight) { // Assume the source dimensions are fine
UINT nTargetWidth = nSourceWidth; UINT nTargetHeight = nSourceHeight;
// If the height or the width exceed the allowed maximum, scale it down, or if we are allowing stretching
if ((nTargetWidth > nMaxWidth) || (nTargetHeight > nMaxHeight) || bStretchSmallImages) { SIZE sizeDesiredImageSize = PrintScanUtil::ScalePreserveAspectRatio( nMaxWidth, nMaxHeight, nTargetWidth, nTargetHeight ); nTargetWidth = sizeDesiredImageSize.cx; nTargetHeight = sizeDesiredImageSize.cy; }
// Make sure we have valid sizes
if (nTargetWidth && nTargetHeight) { // Create the target bitmap and make sure it succeeded
Bitmap TargetBitmap( nTargetWidth, nTargetHeight ); if (Ok == TargetBitmap.GetLastStatus()) { // Get a graphics to render to
Graphics *pGraphics = Graphics::FromImage(&TargetBitmap); if (pGraphics) { // Make sure it is valid
if (pGraphics->GetLastStatus() == Ok) { // Draw scaled image
if (pGraphics->DrawImage(&SourceBitmap, 0, 0, nTargetWidth, nTargetHeight) == Ok) { // Get an HBITMAP for this image
TargetBitmap.GetHBITMAP( Color::Black, &hTargetBitmap ); } } // Clean up our dynamically allocated graphics
delete pGraphics; } } } } } } return(hTargetBitmap ? S_OK : E_FAIL);}
// Construct a string like this: JPG;BMP;PNG with all supported extensions
HRESULT CGdiPlusHelper::ConstructCodecExtensionSearchStrings( CSimpleString &strExtensions, Gdiplus::ImageCodecInfo *pImageCodecInfo, UINT nImageCodecCount ){ for (UINT i=0;i<nImageCodecCount;i++) { if (strExtensions.Length()) { strExtensions += TEXT(";"); } strExtensions += CSimpleStringConvert::NaturalString(CSimpleStringWide(pImageCodecInfo[i].FilenameExtension)); } return (strExtensions.Length() ? S_OK : E_FAIL);}
HRESULT CGdiPlusHelper::ConstructDecoderExtensionSearchStrings( CSimpleString &strExtensions ){ return CGdiPlusHelper::ConstructCodecExtensionSearchStrings( strExtensions, m_pImageDecoderInfo, m_nImageDecoderCount );}
HRESULT CGdiPlusHelper::ConstructEncoderExtensionSearchStrings( CSimpleString &strExtensions ){ return CGdiPlusHelper::ConstructCodecExtensionSearchStrings( strExtensions, m_pImageEncoderInfo, m_nImageEncoderCount );}
CImageFileFormatVerifier::CImageFileFormatVerifierItem::CImageFileFormatVerifierItem(void) : m_pSignature(NULL), m_pMask(NULL), m_nLength(0), m_guidFormat(IID_NULL), m_clsidDecoder(IID_NULL){}
CImageFileFormatVerifier::CImageFileFormatVerifierItem::CImageFileFormatVerifierItem( const PBYTE pSignature, const PBYTE pMask, int nLength, const GUID &guidFormat, const CLSID &guidDecoder ) : m_pSignature(NULL), m_pMask(NULL), m_nLength(0), m_guidFormat(IID_NULL), m_clsidDecoder(IID_NULL){ Assign( pSignature, pMask, nLength, guidFormat, guidDecoder );}
CImageFileFormatVerifier::CImageFileFormatVerifierItem::CImageFileFormatVerifierItem( const CImageFileFormatVerifierItem &other ) : m_pSignature(NULL), m_pMask(NULL), m_nLength(0), m_guidFormat(IID_NULL), m_clsidDecoder(IID_NULL){ Assign( other.Signature(), other.Mask(), other.Length(), other.Format(), other.Decoder() );}
CImageFileFormatVerifier::CImageFileFormatVerifierItem &CImageFileFormatVerifier::CImageFileFormatVerifierItem::operator=( const CImageFileFormatVerifierItem &other ){ if (this != &other) { return Assign( other.Signature(), other.Mask(), other.Length(), other.Format(), other.Decoder() ); } else return *this;}
CImageFileFormatVerifier::CImageFileFormatVerifierItem &CImageFileFormatVerifier::CImageFileFormatVerifierItem::Assign( const PBYTE pSignature, const PBYTE pMask, int nLength, const GUID &guidFormat, const CLSID &clsidDecoder ){ Destroy(); bool bOK = false; m_nLength = nLength; m_guidFormat = guidFormat; m_clsidDecoder = clsidDecoder; if (nLength && pSignature && pMask) { m_pSignature = new BYTE[nLength]; m_pMask = new BYTE[nLength]; if (m_pSignature && m_pMask) { CopyMemory( m_pSignature, pSignature, nLength ); CopyMemory( m_pMask, pMask, nLength ); bOK = true; } } if (!bOK) { Destroy(); } return *this;}
void CImageFileFormatVerifier::CImageFileFormatVerifierItem::Destroy(void){ if (m_pSignature) { delete[] m_pSignature; m_pSignature = NULL; } if (m_pMask) { delete[] m_pMask; m_pMask; } m_nLength = 0; m_guidFormat = IID_NULL; m_clsidDecoder = IID_NULL;}
CImageFileFormatVerifier::CImageFileFormatVerifierItem::~CImageFileFormatVerifierItem(void){ Destroy();}
PBYTE CImageFileFormatVerifier::CImageFileFormatVerifierItem::Signature(void) const{ return m_pSignature;}
PBYTE CImageFileFormatVerifier::CImageFileFormatVerifierItem::Mask(void) const{ return m_pMask;}
int CImageFileFormatVerifier::CImageFileFormatVerifierItem::Length(void) const{ return m_nLength;}
GUID CImageFileFormatVerifier::CImageFileFormatVerifierItem::Format(void) const{ return m_guidFormat;}
CLSID CImageFileFormatVerifier::CImageFileFormatVerifierItem::Decoder(void) const{ return m_clsidDecoder;}
bool CImageFileFormatVerifier::CImageFileFormatVerifierItem::Match( PBYTE pBytes, int nLen ) const{ if (nLen < Length()) { return false; } for (int i=0;i<Length();i++) { if (false == ((pBytes[i] & m_pMask[i]) == m_pSignature[i])) { return false; } } return true;}
CImageFileFormatVerifier::CImageFileFormatVerifier(void) : m_nMaxSignatureLength(0), m_pSignatureBuffer(NULL){ // Get the decoder count and size of the decoder info array
UINT nImageDecoderCount = 0, cbCodecs = 0; if (Gdiplus::Ok == Gdiplus::GetImageDecodersSize( &nImageDecoderCount, &cbCodecs )) { // Make sure we got good sizes back
if (cbCodecs && nImageDecoderCount) { // Allocate the array
Gdiplus::ImageCodecInfo *pImageDecoderInfo = static_cast<Gdiplus::ImageCodecInfo*>(LocalAlloc(LPTR,cbCodecs)); if (pImageDecoderInfo) { // Get the actual decoder info
if (Gdiplus::Ok == Gdiplus::GetImageDecoders( nImageDecoderCount, cbCodecs, pImageDecoderInfo )) { // Add each decoder to the format list
for (UINT i=0;i<nImageDecoderCount;i++) { // Add each signature to the format list
for (UINT j=0;j<pImageDecoderInfo[i].SigCount;j++) {#if defined(DBG)
CSimpleString strPattern; CSimpleString strMask; for (ULONG x=0;x<pImageDecoderInfo[i].SigSize;x++) { strPattern += CSimpleString().Format( TEXT("%02X"), ((const PBYTE)(pImageDecoderInfo[i].SigPattern+(j*pImageDecoderInfo[i].SigSize)))[x] ); strMask += CSimpleString().Format( TEXT("%02X"), ((const PBYTE)(pImageDecoderInfo[i].SigMask+(j*pImageDecoderInfo[i].SigSize)))[x] ); } //WIA_PRINTGUID((pImageDecoderInfo[i].FormatID,TEXT("FormatID")));
//WIA_PRINTGUID((pImageDecoderInfo[i].Clsid,TEXT(" Clsid")));
//WIA_TRACE((TEXT(" strPattern: %s, strMask: %s, SigSize: %d"), strPattern.String(), strMask.String(), pImageDecoderInfo[i].SigSize ));
#endif
m_FileFormatVerifierList.Append( CImageFileFormatVerifier::CImageFileFormatVerifierItem( (const PBYTE)(pImageDecoderInfo[i].SigPattern+(j*pImageDecoderInfo[i].SigSize)), (const PBYTE)(pImageDecoderInfo[i].SigMask+(j*pImageDecoderInfo[i].SigSize)), pImageDecoderInfo[i].SigSize, pImageDecoderInfo[i].FormatID, pImageDecoderInfo[i].Clsid ) ); } } } // Free the array
LocalFree(pImageDecoderInfo); } } }
// Assume the max length is Zero
m_nMaxSignatureLength = 0;
// For each signature, check if it is greater in length than the maximum.
for (int i=0;i<m_FileFormatVerifierList.Size();i++) { // If it is the longest, save the length
if (m_FileFormatVerifierList[i].Length() > m_nMaxSignatureLength) { m_nMaxSignatureLength = m_FileFormatVerifierList[i].Length(); } }
// If we have a valid max length, allocate a buffer to hold the file's data
if (m_nMaxSignatureLength) { m_pSignatureBuffer = new BYTE[m_nMaxSignatureLength]; }
// If anything failed, free everything
if (!IsValid()) { Destroy(); }}
void CImageFileFormatVerifier::Destroy(void){ // Free the file signature buffer
if (m_pSignatureBuffer) { delete[] m_pSignatureBuffer; m_pSignatureBuffer = NULL; } m_nMaxSignatureLength = 0; m_FileFormatVerifierList.Destroy();}
bool CImageFileFormatVerifier::IsValid(void) const{ return (m_pSignatureBuffer && m_nMaxSignatureLength && m_FileFormatVerifierList.Size());}
CImageFileFormatVerifier::~CImageFileFormatVerifier(void){ Destroy();}
GUID CImageFileFormatVerifier::GetImageType( LPCTSTR pszFilename ){ // Assume we will not find a match
GUID guidResult = IID_NULL;
// Open the file for reading
HANDLE hFile = CreateFile( pszFilename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); if (INVALID_HANDLE_VALUE != hFile) { // Read the maximum signature length number of bytes
DWORD dwBytesRead = 0; if (ReadFile( hFile, m_pSignatureBuffer, m_nMaxSignatureLength, &dwBytesRead, NULL )) { // Make sure we got some bytes
if (dwBytesRead) { // Go though the list and try to find a match
for (int i=0;i<m_FileFormatVerifierList.Size();i++) { // If we found a match, we are done
if (m_FileFormatVerifierList[i].Match(m_pSignatureBuffer,dwBytesRead)) { guidResult = m_FileFormatVerifierList[i].Format(); break; } } } } // Close the file
CloseHandle(hFile); }
// This will contain IID_NULL if no matching image type was found
return guidResult;}
bool CImageFileFormatVerifier::IsImageFile( LPCTSTR pszFilename ){ //WIA_PUSH_FUNCTION((TEXT("CImageFileFormatVerifier::IsImageFile(%s)"),pszFilename));
// Try to find the image type
GUID guidImageType = GetImageType(pszFilename);
//WIA_PRINTGUID((guidImageType,TEXT("guidImageType")));
// If the image type is IID_NULL, it isn't an image
return ((IID_NULL != guidImageType) != FALSE);}
|
