cdib_vc.cpp

CONAXCA的源代码

// CDIB.cpp: implementation of the CDIB class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "VcImage.h"
#include "CDib_VC.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDIB::CDIB()
{

}

CDIB::~CDIB()
{

}

CDIB::CDIB(BYTE *m_lpdib)
{
   BITMAPINFOHEADER *lpbih;

   lpbi=(BITMAPINFO *) m_lpdib;

   lpbih=&(lpbi->bmiHeader);
   wid=lpbih->biWidth;
   hei=lpbih->biHeight;
   bits=lpbih->biBitCount;
   bpl=((long)wid*bits+31)/32*4;
   bpp=(bits+1)/8;

   colors=1<<lpbih->biBitCount;
   if(lpbih->biBitCount>8)   colors=0;
   else if(lpbih->biClrUsed!=0) 
		colors=lpbih->biClrUsed;

   lpbits=&m_lpdib[sizeof(BITMAPINFOHEADER)+
		                 colors*sizeof(RGBQUAD)];
}

CDIB::CDIB(BITMAPINFO *m_lpbi,BYTE *m_lpbits)
{
   BITMAPINFOHEADER *lpbih;

   lpbi=m_lpbi;		
   lpbits=m_lpbits;

   lpbih=&(lpbi->bmiHeader);
   wid=lpbih->biWidth;
   hei=lpbih->biHeight;
   bits=lpbih->biBitCount;
   bpl=((long)wid*bits+31)/32*4;
   bpp=(bits+1)/8;
   colors=1<<lpbih->biBitCount;
   if(lpbih->biBitCount>8)   colors=0;
   else if(lpbih->biClrUsed!=0) 
		colors=lpbih->biClrUsed;
}

BYTE* CDIB::DibAddress(int x,int y)
{
   BYTE   *lp;
   DWORD  le;
   int    yy;
 
   if (bits<8)  return 0;
   if ((x<0)||(y<0)||(x>=wid)||(y>=hei)) return 0;
   yy = hei-1-y;
   le = (DWORD) bpl*yy+bpp*x;
   lp = (BYTE *) lpbits + le;
   return(lp);
}

DWORD CDIB::pixel(int x,int y,DWORD c)
{
   BYTE   *lp;
   DWORD  dd=0;

   lp = DibAddress(x,y);
   if (lp==NULL) return 0;
   if (c==0xffffffff) {
      memcpy(&dd,lp,bpp);
   }
   else {  
	  memcpy(lp,&c,bpp);
   }
   return(dd);
}

DWORD CDIB::getpixel(int x,int y)
{
   return(pixel(x,y,(DWORD)0xffffffff));
}

void  CDIB::setpixel(int x,int y,DWORD c)
{
   pixel(x,y,c);
}

void  CDIB::getset(int x,int y,int Dx,int Dy,BYTE *buf,int flag)
{
   BYTE  *lp;
   int   i,dw,dh,delta=0;

   if ((bits<8)||(x+Dx<=0)) return;
   if (x<0) {                                             //  左边越界
      delta=-x;    x=0;
   }
   if ((x<0)||(y<0)||(x>=wid)||(y>=hei)) return;
   Dx *= bpp;                        //  像素地址转换成字节地址
   delta *= bpp;                           //  左边不显示的部分
   dw=min(Dx,(int) bpl-bpp*x);    
   dh=min(Dy,(int) hei-y);
   buf += delta;                        //  调整输入输出像素数据首地址
   dw  -= delta;                                  //  调整实际显示宽度
   lp = DibAddress(x,y);
   for (i=0;i<dh;i++) {
      if (flag==0) {
         memcpy(lp,buf,dw);                               //  写入数据
      }
      else {
         memcpy(buf,lp,dw);                               //  读出数据
	  }
      buf += Dx;	lp -= bpl;
   }
}

void  CDIB::getimage(int x,int y,int Dx,int Dy,BYTE *buf)
{
   getset(x,y,Dx,Dy,buf,1);
}

void  CDIB::setimage(int x,int y,int Dx,int Dy,BYTE *buf)
{
   getset(x,y,Dx,Dy,buf,0);
}

void  CDIB::setwin(int x,int y,int Dx,int Dy,DWORD color)
{
   int    i,dw,dh,k,len;
   BYTE*  buf;

   if (bits<8) return;
   if ((x<0)||(y<0)||(x>=wid)||(y>=hei)) return;
   Dx *= bpp;
   dw=min(Dx,(int) bpl-x*bpp);   
   dh=min(Dy,(int) hei-y);
   dw/=bpp;
   if (dw==bpp) len=dh;
   else         len=dw;

   buf=(BYTE*)malloc(len*bpp);
   if (bpp==1)  memset(buf,(BYTE)color,len);
   else {
	  for (i=0,k=0;i<len;i++,k+=bpp)
	     memcpy(&buf[k],&color,bpp);
   }
   if (dw==bpp)
	  setimage(x,y,1,dh,(BYTE*) buf);
   else {
	  for (i=0;i<dh;i++) {
		 setimage(x,y+i,dw,1,(BYTE*) buf);
	  }
   }
   free(buf);
}

void  CDIB::getpalette(int n,int *pr,int *pg,int *pb)
{
   BYTE *hpal;

   if (bits>8)  return;
   hpal=(BYTE *) lpbi + sizeof(BITMAPINFOHEADER);
   *pb=hpal[4*n];
   *pg=hpal[4*n+1];
   *pr=hpal[4*n+2];
}

void  CDIB::setpalette(int n,int r,int g,int b)
{
   BYTE *hpal;

   if (bits>8)  return;
   hpal=(BYTE *) lpbi + sizeof(BITMAPINFOHEADER);
   hpal[4*n]  =(BYTE) b;
   hpal[4*n+1]=(BYTE) g;
   hpal[4*n+2]=(BYTE) r;
}

int  CDIB::GetWidth(void)
{
   return(wid);
}

int  CDIB::GetHeight(void)
{
   return(hei);
}

int  CDIB::GetBitCount(void)
{
   return(bits);
}

int  CDIB::GetBytesPerLine(void)
{
   return(bpl);
}

int  CDIB::GetBytesPerPixel(void)
{
   return(bpp);
}

int  CDIB::GetColors(void)
{
   return(colors);
}

long CDIB::GetSize(void)
{
   return((long) bpl*hei);
}

COLORREF DWORD2CLRREF(DWORD c)
{
   BYTE		i;
   union    COLOR {
      DWORD     color;
      COLORREF  clrref;
      BYTE		c[4];
   } col;

   col.color=c;
   i=col.c[0];		col.c[0]=col.c[2];
   col.c[2]=i;
   return(col.clrref);
}

DWORD CLRREF2DWORD(COLORREF colorref)
{
   BYTE		i;
   union	COLOR {
      DWORD     color;
      COLORREF  clrref;
      BYTE		c[4];
   } col;

   col.clrref=colorref;
   i=col.c[0];		col.c[0]=col.c[2];
   col.c[2]=i;
   return(col.color);
}

DWORD BGR(int b,int g,int r)
{
   DWORD rr,gg,bb;

   rr=r;        gg=g;
   bb=b;
   bb=bb+(gg<<8)+(rr<<16);
   return(bb);
}