imageloadingtestdlg.cpp

windows ce下的jpeg、bmp图的支持程序

// ImageLoadingTestDlg.cpp : implementation file
//

#include "stdafx.h"
#include "ImageLoadingTest.h"
#include "ImageLoadingTestDlg.h"
#include "imaging.h"
#include "initguid.h"
#include "imgguids.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CImageLoadingTestDlg dialog

CImageLoadingTestDlg::CImageLoadingTestDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CImageLoadingTestDlg::IDD, pParent),
	  m_hBitmap(0)
{
	//{{AFX_DATA_INIT(CImageLoadingTestDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

CImageLoadingTestDlg::~CImageLoadingTestDlg()
{
	DeleteObject(m_hBitmap);
}


void CImageLoadingTestDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CImageLoadingTestDlg)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CImageLoadingTestDlg, CDialog)
	//{{AFX_MSG_MAP(CImageLoadingTestDlg)
	ON_WM_PAINT()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

HBITMAP LoadImageFromFile(const CString &strFileName);

BOOL CImageLoadingTestDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	CenterWindow(GetDesktopWindow());	// center to the hpc screen

	m_hBitmap = LoadImageFromFile(TEXT("\\My Documents\\test.jpg"));
	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

static DWORD CALLBACK GetImageData(LPSTR szBuffer, DWORD dwBufferMax, LPARAM lParam)
{
	FILE* f = (FILE*)lParam;
	size_t c = fread(szBuffer, 1, dwBufferMax, f); 
	return c;
}

#ifndef DecompressImageInfo

class IImageRender;
typedef void (CALLBACK *PROGRESSFUNC)(IImageRender *pRender, BOOL bComplete, LPARAM lParam);
typedef DWORD (CALLBACK *GETDATAFUNC)(LPSTR szBuffer, DWORD dwBufferMax, LPARAM lParam);

typedef struct tagDecompressImageInfo {
	DWORD dwSize;                                 
	LPBYTE pbBuffer;
	DWORD dwBufferMax;
	DWORD dwBufferCurrent;
	HBITMAP* phBM;                                   
	IImageRender **ppImageRender;                  
	int iBitDepth;      
	LPARAM lParam;                 
	HDC hdc;            
	int iScale;         
	int iMaxWidth;      
	int iMaxHeight;     
	GETDATAFUNC pfnGetData;       
	PROGRESSFUNC pfnImageProgress;         
	COLORREF crTransparentOverride; 
} DecompressImageInfo;

#endif 

HBITMAP LoadImageWithImgdecmp(const CString &strFileName)
{
	FILE* f = _tfopen(strFileName, TEXT("rb"));
	if (! f) {
		return 0;
	}

	CWindowDC dc(0);

	DecompressImageInfo dii;
	
	HBITMAP hBitmap = 0;
	
	const int nBuffSize = 4096;
	BYTE buff[nBuffSize];
	
	dii.dwSize = sizeof(DecompressImageInfo);
	dii.pbBuffer = buff;					
	dii.dwBufferMax = nBuffSize;				
	dii.dwBufferCurrent = 0;					
	dii.phBM = &hBitmap;						
	dii.ppImageRender = NULL;					
	dii.iBitDepth = GetDeviceCaps(dc.m_hDC, BITSPIXEL);
	dii.lParam = LPARAM(f);
	dii.hdc = 0;										
	dii.iScale = 100;										
	dii.iMaxWidth = 10000;								
	dii.iMaxHeight = 10000;								
	dii.pfnGetData = GetImageData;				
	dii.pfnImageProgress = 0;				
	dii.crTransparentOverride = (UINT) -1;	
	
	HINSTANCE hDll = LoadLibrary(TEXT("imgdecmp.dll"));
	if (!hDll) {
		fclose(f);
		return 0;
	} 
	typedef HRESULT (*DecompressImageIndirect_t)(DecompressImageInfo *pParams);
	DecompressImageIndirect_t proc = (DecompressImageIndirect_t)GetProcAddress(hDll, TEXT("DecompressImageIndirect"));
	if (! proc) {
		FreeLibrary(hDll);
		fclose(f);
		return 0;
	}
	HRESULT hr = proc(&dii);

	fclose(f);
	FreeLibrary(hDll);

	if (FAILED(hr)) {
		return 0;
	} else {
		return hBitmap;
	}
}

HBITMAP LoadImageWithImagingApi(const CString &strFileName)
{
    IImagingFactory *pImgFactory = NULL;
    IImage *pImage = NULL;
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
	HBITMAP hResult = 0;
    if (SUCCEEDED(CoCreateInstance (CLSID_ImagingFactory,
                                    NULL,
                                    CLSCTX_INPROC_SERVER,
                                    IID_IImagingFactory,
                                    (void **)&pImgFactory)))
    {
		ImageInfo imageInfo;
        if (SUCCEEDED(pImgFactory->CreateImageFromFile(strFileName, &pImage))
			&& SUCCEEDED(pImage->GetImageInfo(&imageInfo)))
        {
			CWindowDC dc(0);
			CDC dcBitmap;
			dcBitmap.CreateCompatibleDC(&dc);
			hResult = CreateCompatibleBitmap(dc.GetSafeHdc(), imageInfo.Width, imageInfo.Height);
			if (hResult) {
				HGDIOBJ hOldBitmap = dcBitmap.SelectObject(hResult);
		        pImage->Draw(dcBitmap.GetSafeHdc(), CRect(0, 0, imageInfo.Width, imageInfo.Height), NULL);
				dcBitmap.SelectObject(hOldBitmap);
			}
			pImage->Release();
        }
        pImgFactory->Release();
    }
    CoUninitialize();

	return hResult;
}


HBITMAP LoadImageFromFile(const CString &strFileName)
{
	OSVERSIONINFO vi;
	memset(&vi, 0, sizeof(vi));
	vi.dwOSVersionInfoSize = sizeof(vi);
	VERIFY(GetVersionEx(&vi));
	if (vi.dwMajorVersion>=5) {
		return LoadImageWithImagingApi(strFileName);
	} else {
		return LoadImageWithImgdecmp(strFileName);
	}
}


void CImageLoadingTestDlg::OnPaint() 
{
	CPaintDC dc(this); // device context for painting

	CDC dcImage;
	dcImage.CreateCompatibleDC(&dc);
	HGDIOBJ hOld = dcImage.SelectObject(m_hBitmap);
	BITMAP bitmap;
	GetObject(m_hBitmap, sizeof(BITMAP), &bitmap);
	CRect rectClient;
	GetClientRect(rectClient);
	
	dc.BitBlt((rectClient.Width()-bitmap.bmWidth)/2+rectClient.left, (rectClient.Height()-bitmap.bmHeight)/2+rectClient.top,
		bitmap.bmWidth, bitmap.bmHeight, &dcImage, 0, 0, SRCCOPY);

	dcImage.SelectObject(hOld);

}