在vc6实现png图像文件的显示方法

vc6本身不会提供对png图像文件的显示支持，在这篇文章中谈谈怎样借用libpnp开源代码来实现这一点。

 

1. 编译zlib

首先在http://zlib.net/下载zlib 源码，以zlib-1.2.4为例，解压到硬盘任何一个地方，假设为e:/zlib-1.2.4,

在e:/zlib-1.2.4/project/visualc6有vc6工程，用vc6打开zlib.dsw，编译产生静态库zlib.lib，zlibd.lib(debug), 并连同zconf.h,zlib.h拷贝一份放在vc6的系统目录下(include,lib)，

2.编译libpng

http://www.libpng.org/下载最新的源码，这里以lpng141.zip为例，解压到硬盘任何一个地方，假设为e:/lpng141,在子目录projects中我们能发现有一个visualc6子目录，很显然，这里面放的是vc6的工程文件，用vc6打开libpng.dsw，编译产生静态库libpng.lib，libpngd.lib(debug), 并连同png.h,pngconf.h拷贝一份放在vc6的系统目录下(include,lib)，

 

3.使用libpng,

建立一个SDI工程pngSDI,

实现如下的一个类，类的定义imagPNG.h：

// ImagPNG.h: interface for the CImagPNG class.
//
//

#if !defined(AFX_IMAGPNG_H__3A5C27AE_0B49_4506_BD0B_CCB61F2CF91D__INCLUDED_)
#define AFX_IMAGPNG_H__3A5C27AE_0B49_4506_BD0B_CCB61F2CF91D__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <png.h>

#define ALPHABLED(b,f,a)  (b * (255 -a ) + f * a )/255
#define MARGIN 0
class CImagPNG 
{
public:
 HBITMAP LoadResource(UINT nIDResource);
 HBITMAP LoadFromFile(LPCTSTR lpFileName);
 CImagPNG( int cxWinSize, int cyWinSize,HDC hdc);
 virtual ~CImagPNG();

private:
 HBITMAP Read( FILE *fl);
 BOOL InitBitmap (BYTE *pDiData, int cxWinSize, int cyWinSize);
 BOOL FillBitmap (BYTE *pDiData,BYTE *pbImage,int cx,int cy,int cChannel);
 HDC m_hdc ;
 int m_cxWinSize;
 int m_cyWinSize;
 png_byte* m_pbImageData;
 static void png_read_data(png_structp png_ptr, png_bytep data, png_size_t length);
};

#endif // !defined(AFX_IMAGPNG_H__3A5C27AE_0B49_4506_BD0B_CCB61F2CF91D__INCLUDED_)

实现cpp文件：

// ImagPNG.cpp: implementation of the CImagPNG class.
//
//

#include "stdafx.h"
#include "ImagPNG.h"

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

//
// Construction/Destruction
//

CImagPNG::CImagPNG( int cxWinSize, int cyWinSize,HDC hdc)
{
 m_hdc = hdc;

    m_cxWinSize = cxWinSize;
 m_cyWinSize = cyWinSize;
 m_pbImageData = NULL;
}

CImagPNG::~CImagPNG()
{
 if (m_pbImageData)
 {
  free (m_pbImageData);
  m_pbImageData = NULL;
 }
}

void CImagPNG::png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
 png_size_t check;

   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
    * instead of an int, which is what fread() actually returns.
    */
   check = (png_size_t)fread(data, (png_size_t)1, length,
      (FILE *)png_ptr->io_ptr);

   if (check != length)
   {
      png_error(png_ptr, "Read Error");
   }
}

HBITMAP CImagPNG::LoadFromFile(LPCTSTR lpFileName)
{

 FILE *fpin;
 
 if ((fpin = fopen(lpFileName, "rb")) == NULL)
 {
  return NULL;
 }
    HBITMAP hbp = Read(fpin);

 fclose(fpin);
 return hbp;
}

BOOL CImagPNG::FillBitmap(BYTE *pDiData, BYTE *pbImage, int cx, int cy,int cChannel)
{
 BYTE *pStretchedImage;
 BYTE *pImg;
    BYTE *src, *dst;
    BYTE r, g, b, a;
    const int cDIChannels = 3;
    WORD wImgRowBytes;
    WORD wDIRowBytes;
    int cxImgPos, cyImgPos;
    int xImg, yImg;
    int xWin, yWin;
 int cxNewSize, cyNewSize;
 int xOld, yOld;
    int xNew, yNew;
 COLORREF bkCol=GetSysColor(COLOR_BTNFACE);// RGB(100,120,120);//GetBkColor(m_hdc);

     cxNewSize = m_cxWinSize - 2 * MARGIN;
        cyNewSize = m_cyWinSize - 2 * MARGIN;

        // stretch the image to it's window determined size

        // the following two are the same, but the first has side-effects
        // because of rounding
//      if ((cyNewSize / cxNewSize) > (cyImgSize / cxImgSize))
        if ((cyNewSize * cx) > (cy * cxNewSize))
        {
            cyNewSize = cxNewSize * cy / cx;
            cxImgPos = MARGIN;
            cyImgPos = (m_cyWinSize - cyNewSize) / 2;
        }
        else
        {
            cxNewSize = cyNewSize * cx / cy;
            cyImgPos = MARGIN;
            cxImgPos = (m_cxWinSize - cxNewSize) / 2;
        }

        pStretchedImage =(BYTE*) malloc (cChannel * cxNewSize * cyNewSize);
        pImg = pStretchedImage;

        for (yNew = 0; yNew < cyNewSize; yNew++)
        {
            yOld = yNew * cy / cyNewSize;
            for (xNew = 0; xNew < cxNewSize; xNew++)
            {
                xOld = xNew * cx / cxNewSize;

                r = *(pbImage + cChannel * ((yOld * cx) + xOld) + 0);
                g = *(pbImage + cChannel * ((yOld * cx) + xOld) + 1);
                b = *(pbImage + cChannel * ((yOld * cx) + xOld) + 2);
                *pImg++ = r;
                *pImg++ = g;
                *pImg++ = b;
                if (cChannel == 4)
                {
                    a = *(pbImage + cChannel * ((yOld * cx) + xOld)
                        + 3);
                    *pImg++ = a;
                }
            }
        }

        // calculate row-bytes

        wImgRowBytes = cChannel * cxNewSize;
        wDIRowBytes = (WORD) ((cDIChannels * m_cxWinSize + 3L) >> 2) << 2;

        // copy image to screen

        for (yImg = 0, yWin = cyImgPos; yImg < cyNewSize; yImg++, yWin++)
        {
            if (yWin >= m_cyWinSize - cyImgPos)
                break;
            src = pStretchedImage + yImg * wImgRowBytes;
            dst = pDiData + yWin * wDIRowBytes + cxImgPos * cDIChannels;

            for (xImg = 0, xWin = cxImgPos; xImg < cxNewSize; xImg++, xWin++)
            {
                if (xWin >= m_cxWinSize - cxImgPos)
                    break;
                r = *src++;
                g = *src++;
                b = *src++;
                if (cChannel == 4)
                {
                    a = *src++;
                }
    *dst++ = ALPHABLED(GetBValue(bkCol),b,a );// b; /* note the reverse order */
    *dst++ = ALPHABLED(GetGValue(bkCol),g,a );//g;
    *dst++ = ALPHABLED(GetRValue(bkCol),r,a );//r;
            }
        }

        // free memory

        if (pStretchedImage != NULL)
        {
            free (pStretchedImage);
            pStretchedImage = NULL;
        }

 return TRUE;
 // calculate the central position 
 cxImgPos = 0;
 cyImgPos = 0;

 // check for image larger than window
 
 if (cxImgPos < MARGIN)
  cxImgPos = MARGIN;
 if (cyImgPos < MARGIN)
  cyImgPos = MARGIN;
 // calculate both row-bytes 
 wImgRowBytes = cChannel * cx;
 wDIRowBytes = (WORD) ((cDIChannels * cx + 3L) >> 2) << 2;
 
 // copy image to screen 
 for (yImg = 0, yWin = cyImgPos; yImg < cy; yImg++, yWin++)
 {
  if (yWin >= cy - MARGIN)
                break;
  src = pbImage + yImg * wImgRowBytes;
  dst = pDiData + yWin * wDIRowBytes + cxImgPos * cDIChannels;
  
  for (xImg = 0, xWin = cxImgPos; xImg < cx; xImg++, xWin++)
  {
    if (xWin >= cx - MARGIN)
                    break;
   r = *src++;
   g = *src++;
   b = *src++;   
   
   if (cChannel == 4)
   {
    a = *src++;
   // TRACE("Alpha %d /n",a);
   }
   
   *dst++ = ALPHABLED(GetBValue(bkCol),b,a );// b; /* note the reverse order */
   *dst++ = ALPHABLED(GetGValue(bkCol),g,a );//g;
   *dst++ = ALPHABLED(GetRValue(bkCol),r,a );//r;
  }
 }
 
    return TRUE;
}

BOOL CImagPNG::InitBitmap(BYTE *pDiData, int cxWinSize, int cyWinSize)
{
    BYTE *dst;
    int x, y, col;

    // initialize the background with gray

    dst = pDiData;
    for (y = 0; y < cyWinSize; y++)
    {
       // col = 0;
        for (x = 0; x < cxWinSize; x++)
        {
            // fill with GRAY
            *dst++ = 127;
            *dst++ = 127;
            *dst++ = 127;
            col += 3;
        }
        // rows start on 4 byte boundaries
        while ((col % 4) != 0)
        {
            dst++;
            col++;
        }
    }

    return TRUE;

}

HBITMAP CImagPNG::LoadResource(UINT nIDResource)
{
 LPCTSTR szResourceName = MAKEINTRESOURCE(nIDResource);
 HRSRC hPicture = FindResource(AfxGetResourceHandle(),szResourceName,"PNG");
 HGLOBAL hResData;
 if (!hPicture || !(hResData = ::LoadResource(AfxGetResourceHandle(),hPicture)))
 {
  TRACE(_T("Load (resource): Error loading resource %s/n"),szResourceName);
  return NULL;
 };
 DWORD dwSize = SizeofResource(AfxGetResourceHandle(),hPicture);

 // hResData is not the real HGLOBAL (we can't lock it)
 // let's make it real
 LPVOID pSrc = LockResource(hResData);
 FILE* stream = tmpfile();
 if (NULL != stream)
 {
  fwrite(pSrc, dwSize, 1, stream);
  fseek(stream,0,SEEK_SET);

 }
 FreeResource(hResData);
 HBITMAP btmap = Read(stream);

    fclose(stream);
    return btmap;
}

HBITMAP CImagPNG::Read(FILE *fl)
{
 png_structp read_ptr;
 png_infop read_info_ptr, end_info_ptr;
 png_bytep row_buf;
 png_uint_32 iWidth, iHeight;
 int iBitDepth, iColorType;
 
 read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 
 read_info_ptr = png_create_info_struct(read_ptr);
 
 if (setjmp(png_jmpbuf(read_ptr)))
 {
  png_free(read_ptr, row_buf);
  row_buf = NULL;
  png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
  return NULL;
 }
 
 
 
 
 png_byte pbSig [8];
 fread(pbSig, 1, 8, fl);
    if (png_sig_cmp(pbSig, 0, 8))
    {
       
        return NULL;
    }
 
 png_set_read_fn(read_ptr, (png_voidp)fl, png_read_data);
 
 png_set_sig_bytes(read_ptr, 8);
 // read all PNG info up to image data
 
 png_read_info(read_ptr, read_info_ptr);
 
 // get width, height, bit-depth and color-type
 
 png_get_IHDR(read_ptr, read_info_ptr, &iWidth, &iHeight, &iBitDepth,
  &iColorType, NULL, NULL, NULL);
 
 // expand images of all color-type and bit-depth to 3x8 bit RGB images
 // let the library process things like alpha, transparency, background
 
 if (iBitDepth == 16)
  png_set_strip_16(read_ptr);
 if (iColorType == PNG_COLOR_TYPE_PALETTE)
  png_set_expand(read_ptr);
 if (iBitDepth < 8)
  png_set_expand(read_ptr);
 if (png_get_valid(read_ptr, read_info_ptr, PNG_INFO_tRNS))
  png_set_expand(read_ptr);
 if (iColorType == PNG_COLOR_TYPE_GRAY ||
  iColorType == PNG_COLOR_TYPE_GRAY_ALPHA)
  png_set_gray_to_rgb(read_ptr);
 
 png_color_16* pBackground;
 png_color* pBkgColor ;
 // set the background color to draw transparent and alpha images over.
 if (png_get_bKGD(read_ptr, read_info_ptr, &pBackground))
 {
  png_set_background(read_ptr, pBackground, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
  pBkgColor->red   = (byte) pBackground->red;
  pBkgColor->green = (byte) pBackground->green;
  pBkgColor->blue  = (byte) pBackground->blue;
 }
 else
 {
  pBkgColor = NULL;
 }
 
 double dGamma;
 // if required set gamma conversion
 if (png_get_gAMA(read_ptr, read_info_ptr, &dGamma))
  png_set_gamma(read_ptr, (double) 2.2, dGamma);
 
 // after the transformations have been registered update info_ptr data
 
 png_read_update_info(read_ptr, read_info_ptr);
 
 // get again width, height and the new bit-depth and color-type
 
 png_get_IHDR(read_ptr, read_info_ptr, &iWidth, &iHeight, &iBitDepth,
  &iColorType, NULL, NULL, NULL);
 
 
 // row_bytes is the width x number of channels
 png_uint_32 ulRowBytes;
 png_uint_32 ulChannels;
 ulRowBytes = png_get_rowbytes(read_ptr, read_info_ptr);
 ulChannels = png_get_channels(read_ptr, read_info_ptr);
 
 
 // now we can allocate memory to store the image
 
 static png_byte** ppbRowPointers = NULL;
 if (m_pbImageData)
 {
  free (m_pbImageData);
  m_pbImageData = NULL;
 }
 if ((m_pbImageData = (png_byte *) malloc(ulRowBytes * (iHeight)
  * sizeof(png_byte))) == NULL)
 {
  png_error(read_ptr, "Visual PNG: out of memory");
  return NULL;
 }
 
 
 // and allocate memory for an array of row-pointers
 
 if ((ppbRowPointers = (png_bytepp) malloc((iHeight)
  * sizeof(png_bytep))) == NULL)
 {
  png_error(read_ptr, "Visual PNG: out of memory");
  return NULL;
 }
 
 // set the individual row-pointers to point at the correct offsets
 int i;
 for (i = 0; i < (iHeight); i++)
  ppbRowPointers[i] = m_pbImageData + i * ulRowBytes;
 
 // now we can go ahead and just read the whole image
 
 png_read_image(read_ptr, ppbRowPointers);
 
 // read the additional chunks in the PNG file (not really needed)
 
 png_read_end(read_ptr, NULL);
 
 // and we're done
 
 free (ppbRowPointers);
 ppbRowPointers = NULL;
 png_destroy_read_struct(&read_ptr, &read_info_ptr, NULL);

 //Display
 WORD  wDIRowBytes;
 wDIRowBytes = (WORD) ((3 * iWidth + 3L) >> 2) << 2;
 BYTE *pDib = (BYTE *) malloc (sizeof(BITMAPINFOHEADER) + wDIRowBytes * iHeight);
 memset (pDib, 0, sizeof(BITMAPINFOHEADER));
 
 BITMAPINFOHEADER           *pbmih;
 pbmih = (BITMAPINFOHEADER *) pDib;
 pbmih->biSize = sizeof(BITMAPINFOHEADER);
 pbmih->biWidth = m_cxWinSize;
 pbmih->biHeight = -((long) m_cyWinSize);
 pbmih->biPlanes = 1;
 pbmih->biBitCount = 24;
 pbmih->biCompression = BI_RGB;
 BYTE  *pDiData;
 pDiData = pDib + sizeof(BITMAPINFOHEADER); 
 InitBitmap(pDiData,m_cxWinSize, m_cyWinSize);
 FillBitmap (pDiData,m_pbImageData, iWidth, iHeight, ulChannels);
 HBITMAP hbp=CreateDIBitmap(m_hdc,pbmih,CBM_INIT,pDiData,(BITMAPINFO *)pDib,DIB_RGB_COLORS);
 
 return hbp;
}

其基本思想就是从png提取RGB数据来构造BITMAP对象，有两种方式：

HBITMAP CImagPNG::LoadResource(UINT nIDResource);
 HBITMAP CImagPNG::LoadFromFile(LPCTSTR lpFileName);

 

分别是从资源和文件中构造BITMAP对象，

 

比如要把png图片放在toolbar上可以这样用：

 

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{

 

。。。 。。。

 

//创建CImagPNG对象

 m_pimgPNG = new CImagPNG(64,64,m_wndToolBar.GetDC()->m_hDC);

 

//创建CImaglist对象

 m_imgTool.Create(64,64,ILC_COLOR32,1,0);

 

//从文件中构建bitmap对象

 HBITMAP btmap=m_pimgPNG->LoadFromFile("d://25.png");

 

//加入到imagelist中
 m_imgTool.Add(CBitmap::FromHandle(btmap),RGB(0,0,0));

 

 btmap=m_pimgPNG->LoadFromFile("d://26.png");
 m_imgTool.Add(CBitmap::FromHandle(btmap),RGB(0,0,0));

 

//从资源中构建bitmap对象

 btmap=m_pimgPNG->LoadResource(IDR_PNG1);
 m_imgTool.Add(CBitmap::FromHandle(btmap),RGB(0,0,0));

 

 btmap=m_pimgPNG->LoadResource(IDR_PNG2);
 m_imgTool.Add(CBitmap::FromHandle(btmap),RGB(0,0,0));

 

//最后把imaglist加入到工具条上
 m_wndToolBar.GetToolBarCtrl().SetImageList(&m_imgTool);

效果图：

 

源码下载：http://download.csdn.net/source/2617355