开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
CDIB.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：15k
源码类别：

Windows编程

开发平台：

Visual C++

CDIB.C：源码内容
  1. /*****************************************************************************
  2.  *
  3.  *  CrunchDIB  - shrink a DIB down by 2 with color averaging
  4.  *
  5.  *****************************************************************************/
  6. /**************************************************************************
  7.  *
  8.  *  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  9.  *  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  10.  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  11.  *  PURPOSE.
  12.  *
  13.  *  Copyright (C) 1993 - 1997  Microsoft Corporation.  All Rights Reserved.
  14.  * 
  15.  **************************************************************************/
  18. #include <windows.h>
  19. #include <windowsx.h>
  20. #include <mmsystem.h>
  21. #include <memory.h>
  23. //
  24. // support huge >64k DIBs?
  25. //
  26. #ifndef WIN32
  27. #define HUGE_DIBS
  28. #endif
  29. #ifdef HUGE_DIBS
  30. #define LPBYTE  BYTE _huge *
  31. #define LPWORD  WORD _huge *
  32. #undef FAR
  33. #define FAR _huge
  34. #endif
  36. /*****************************************************************************
  37.  *
  38.  *  These are the standard VGA colors, we will be stuck with until the
  39.  *  end of time!
  40.  *
  41.  *****************************************************************************/
  43. static DWORD VGAColors[16] = {
  44.      0x00000000        // 0000  black
  45.     ,0x00800000        // 0001  dark red
  46.     ,0x00008000        // 0010  dark green
  47.     ,0x00808000        // 0011  mustard
  48.     ,0x00000080        // 0100  dark blue
  49.     ,0x00800080        // 0101  purple
  50.     ,0x00008080        // 0110  dark turquoise
  51.     ,0x00C0C0C0        // 1000  gray
  52.     ,0x00808080        // 0111  dark gray
  53.     ,0x00FF0000        // 1001  red
  54.     ,0x0000FF00        // 1010  green
  55.     ,0x00FFFF00        // 1011  yellow
  56.     ,0x000000FF        // 1100  blue
  57.     ,0x00FF00FF        // 1101  pink (magenta)
  58.     ,0x0000FFFF        // 1110  cyan
  59.     ,0x00FFFFFF        // 1111  white
  60.     };
  62. /*****************************************************************************
  63.  *
  64.  *  bit(b,n)   - get the Nth bit of BYTE b
  65.  *
  66.  *****************************************************************************/
  68. #define bit(b,n) (BYTE)(((b) & (1 << (n))) >> (n))
  70. /*****************************************************************************
  71.  *
  72.  *  SumMono
  73.  *
  74.  *     this routine taks four "mono" values and returns the average value.
  75.  *
  76.  *     ((b0) + (b1) + (b2) + (b3) >= 2)
  77.  *
  78.  *
  79.  *****************************************************************************/
  81. #define SumMono(b0,b1,b2,b3) (BYTE)(((b0) + (b1) + (b2) + (b3) + 2) / 4)
  83. /*****************************************************************************
  84.  *
  85.  *  MapVGA
  86.  *
  87.  *     map a rgb value to a VGA index
  88.  *
  89.  *        0000  black
  90.  *        0001  dark red
  91.  *        0010  dark green
  92.  *        0011  mustard
  93.  *        0100  dark blue
  94.  *        0101  purple
  95.  *        0110  dark turquoise
  96.  *        1000  gray
  97.  *        0111  dark gray
  98.  *        1001  red
  99.  *        1010  green
  100.  *        1011  yellow
  101.  *        1100  blue
  102.  *        1101  pink (magenta)
  103.  *        1110  cyan
  104.  *        1111  white
  105.  *
  106.  *****************************************************************************/
  108. #define MapVGA(r,g,b) (((r&~3) == (g&~3) && (g&~3) == (b&~3)) ?        
  109.         ((r < 64) ? 0 : (r <= 128) ? 8 : (r <= 192) ? 7 : 15) :        
  110.         (((r>192) || (g>192) || (b>192)) ?                             
  111.            (((r>191) ? 1:0) | ((g>191) ? 2:0) | ((b>191) ? 4:0) | 8) : 
  112.            (((r>64) ? 1:0) | ((g>64) ? 2:0) | ((b>64) ? 4:0))) )
  114. /*****************************************************************************
  115.  *
  116.  *  SumRGB
  117.  *
  118.  *****************************************************************************/
  120. #define SumRGB(b0,b1,b2,b3) RGB(
  121.         ((int)pal.palPalEntry[b0].peRed +        
  122.          (int)pal.palPalEntry[b1].peRed +        
  123.          (int)pal.palPalEntry[b2].peRed +        
  124.          (int)pal.palPalEntry[b3].peRed) >> 2,   
  125.                                                  
  126.         ((int)pal.palPalEntry[b0].peGreen +      
  127.          (int)pal.palPalEntry[b1].peGreen +      
  128.          (int)pal.palPalEntry[b2].peGreen +      
  129.          (int)pal.palPalEntry[b3].peGreen) >> 2, 
  130.                                                   
  131.         ((int)pal.palPalEntry[b0].peBlue +       
  132.          (int)pal.palPalEntry[b1].peBlue +       
  133.          (int)pal.palPalEntry[b2].peBlue +       
  134.          (int)pal.palPalEntry[b3].peBlue) >> 2)
  136. /*****************************************************************************
  137.  *
  138.  *  RGB16
  139.  *
  140.  *****************************************************************************/
  142. typedef struct { BYTE b,g,r; } RGB24;
  144. #define RGB16(r,g,b) (
  145.             (((UINT)(r) >> 3) << 10) |  
  146.             (((UINT)(g) >> 3) << 5)  |  
  147.             (((UINT)(b) >> 3) << 0)  )
  149. #define rgb16(r,g,b) (
  150.             ((UINT)(r) << 10) |  
  151.             ((UINT)(g) << 5)  |  
  152.             ((UINT)(b) << 0)  )
  154. //#define RGB16R(rgb)     ((((UINT)(rgb) >> 10) & 0x1F) * 255u / 31u)
  155. //#define RGB16G(rgb)     ((((UINT)(rgb) >> 5)  & 0x1F) * 255u / 31u)
  156. //#define RGB16B(rgb)     ((((UINT)(rgb) >> 0)  & 0x1F) * 255u / 31u)
  158. #define RGB16R(rgb)     aw5to8[((UINT)(rgb) >> 10) & 0x1F]
  159. #define RGB16G(rgb)     aw5to8[((UINT)(rgb) >> 5)  & 0x1F]
  160. #define RGB16B(rgb)     aw5to8[((UINT)(rgb) >> 0)  & 0x1F]
  161. #define RGB16r(rgb)     ((BYTE)((UINT)(rgb) >> 10) & 0x1F)
  162. #define RGB16g(rgb)     ((BYTE)((UINT)(rgb) >> 5)  & 0x1F)
  163. #define RGB16b(rgb)     ((BYTE)((UINT)(rgb) >> 0)  & 0x1F)
  165. /*****************************************************************************
  166.  *
  167.  *  Pel() used for 24bit Crunch
  168.  *
  169.  *****************************************************************************/
  171. #define Pel(p,x) (BYTE)(BitCount == 1 ? Pel1(p,x) : 
  172.                         BitCount == 4 ? Pel4(p,x) : Pel8(p,x))
  174. #define Pel1(p,x)   (BYTE)bit(((LPBYTE)(p))[(x)/8],7-((x)%8))
  175. #define Pel4(p,x)   (BYTE)((x & 1) ? (((LPBYTE)(p))[(x)/2] & 15) : (((LPBYTE)(p))[(x)/2] >> 4))
  176. #define Pel8(p,x)   (BYTE)(((LPBYTE)(p))[(x)])
  177. #define Pel16(p,x)  (((LPWORD)(p))[(x)])
  178. #define Pel24(p,x)  (((RGB24 FAR *)(p))[(x)])
  180. /*****************************************************************************
  181.  *
  182.  *  CrunchDIB  - shrink a DIB down by 2 with color averaging
  183.  *
  184.  *     this routine works on 1,4 bpp DIBs
  185.  *
  186.  *     for mono DIBs it is assumed they are black and white
  187.  *
  188.  *     for 4bpp DIBs it is assumed they use the VGA colors
  189.  *
  190.  *     this routine can't be used "in place"
  191.  *
  192.  *****************************************************************************/
  194. BOOL CrunchDIB(
  195.     LPBITMAPINFOHEADER  lpbiSrc,    // BITMAPINFO of source
  196.     LPVOID              lpSrc,      // input bits to crunch
  197.     LPBITMAPINFOHEADER  lpbiDst,    // BITMAPINFO of dest
  198.     LPVOID              lpDst)      // output bits to crunch
  199. {
  200.     LPBYTE      pbSrc;
  201.     LPBYTE      pbDst;
  202.     LPBYTE      pb;
  203.     LPWORD      pw;
  204.     BYTE        r,g,b,b0,b1,b2,b3;
  205.     WORD        w0,w1,w2,w3;
  206.     RGB24       rgb0,rgb1,rgb2,rgb3;
  207.     int         WidthBytesSrc;
  208.     int         WidthBytesDst;
  209.     UINT        x;
  210.     UINT        y;
  211.     UINT        dx;
  212.     UINT        dy;
  213.     int         i;
  214.     COLORREF    rgb;
  215.     int         BitCount;
  216.     UINT        aw5to8[32];
  218.     struct {
  219.         WORD         palVersion;
  220. WORD         palNumEntries;
  221. PALETTEENTRY palPalEntry[256];
  222.     }   pal;
  224.     if (lpbiSrc->biCompression != BI_RGB)
  225.         return FALSE;
  227.     BitCount = (int)lpbiSrc->biBitCount;
  229.     if (BitCount == 16)
  230.         for (i=0; i<32; i++)
  231.             aw5to8[i] = (UINT)i * 255u / 31u;
  233.     dx = (int)lpbiDst->biWidth;
  234.     WidthBytesDst = (((UINT)lpbiDst->biBitCount * dx + 31)&~31) / 8;
  236.     dy = (int)lpbiSrc->biHeight;
  237.     dx = (int)lpbiSrc->biWidth;
  238.     WidthBytesSrc = (((UINT)lpbiSrc->biBitCount * dx + 31)&~31) / 8;
  240.     dx &= ~1;
  241.     dy &= ~1;
  243.     pbSrc = lpSrc;
  244.     pbDst = lpDst;
  246.     if (lpbiSrc->biClrUsed == 0 && lpbiSrc->biBitCount <= 8)
  247.         lpbiSrc->biClrUsed = (1 << (int)lpbiSrc->biBitCount);
  249.     pal.palVersion = 0x300;
  250.     pal.palNumEntries = (int)lpbiSrc->biClrUsed;
  252.     for (i=0; i<(int)pal.palNumEntries; i++)
  253.     {
  254.         pal.palPalEntry[i].peRed   = ((LPRGBQUAD)(lpbiSrc+1))[i].rgbRed;
  255.         pal.palPalEntry[i].peGreen = ((LPRGBQUAD)(lpbiSrc+1))[i].rgbGreen;
  256.         pal.palPalEntry[i].peBlue  = ((LPRGBQUAD)(lpbiSrc+1))[i].rgbBlue;
  257.         pal.palPalEntry[i].peFlags = 0;
  258.     }
  260.     if (lpbiDst->biBitCount == 8)
  261.         _fmemcpy(lpbiDst+1,lpbiSrc+1,(int)lpbiSrc->biClrUsed*sizeof(RGBQUAD));
  263.     if (lpbiDst->biBitCount == 4)
  264.         _fmemcpy(lpbiDst+1,VGAColors,sizeof(VGAColors));
  266.     if ((int)lpbiDst->biBitCount == (int)lpbiSrc->biBitCount)
  267.     {
  268.         switch((int)lpbiSrc->biBitCount)
  269.         {
  270.         case 1:
  271.             dx = dx / 8;    // dx is byte count
  273.             for (y=0; y<dy; y+=2)
  274.             {
  275.                 pb = pbDst;
  277.                 for (x=0; x<dx; x += 2)
  278.                 {
  279.                     b0 = pbSrc[x];
  280.                     b1 = pbSrc[x + WidthBytesSrc];
  282.                     b = (BYTE)(
  283.                         (SumMono(bit(b0,7), bit(b0,6), bit(b1,7), bit(b1,6)) << 7) |
  284.                         (SumMono(bit(b0,5), bit(b0,4), bit(b1,5), bit(b1,4)) << 6) |
  285.                         (SumMono(bit(b0,3), bit(b0,2), bit(b1,3), bit(b1,2)) << 5) |
  286.                         (SumMono(bit(b0,1), bit(b0,0), bit(b1,1), bit(b1,0)) << 4));
  288.                     b0 = pbSrc[x + 1];
  289.                     b1 = pbSrc[x + 1 + WidthBytesSrc];
  291.                     b |=(SumMono(bit(b0,7), bit(b0,6), bit(b1,7), bit(b1,6)) << 3) |
  292.                         (SumMono(bit(b0,5), bit(b0,4), bit(b1,5), bit(b1,4)) << 2) |
  293.                         (SumMono(bit(b0,3), bit(b0,2), bit(b1,3), bit(b1,2)) << 1) |
  294.                         (SumMono(bit(b0,1), bit(b0,0), bit(b1,1), bit(b1,0)) << 0);
  296.                     *pb++ = b;
  297.                 }
  299.                 pbSrc += WidthBytesSrc*2;
  300.                 pbDst += WidthBytesDst;
  301.             }
  302.             break;
  304.         case 4:
  305.             dx = dx / 2;    // dx is byte count
  307.             for (y=0; y<dy; y+=2)
  308.             {
  309.                 pb = pbDst;
  311.                 for (x=0; x<dx; x+=2)
  312.                 {
  313.                     b0 = pbSrc[x];
  314.                     b1 = pbSrc[x + WidthBytesSrc];
  316.                     rgb = SumRGB((b0 >> 4),(b0 & 0x0F),
  317.                                  (b1 >> 4),(b1 & 0x0F));
  319.                     b = (BYTE)(MapVGA(GetRValue(rgb),GetGValue(rgb),GetBValue(rgb)) << 4);
  321.                     b0 = pbSrc[x + 1];
  322.                     b1 = pbSrc[x + 1 + WidthBytesSrc];
  324.                     rgb = SumRGB((b0 >> 4),(b0 & 0x0F),
  325.                                  (b1 >> 4),(b1 & 0x0F));
  327.                     b |= MapVGA(GetRValue(rgb),GetGValue(rgb),GetBValue(rgb));
  329.                     *pb++ = b;
  330.                 }
  332.                 pbSrc += WidthBytesSrc*2;
  333.                 pbDst += WidthBytesDst;
  334.             }
  335.             break;
  336. #if 0
  337.         case 8:
  338.             {
  339.             HPALETTE hpal;
  341.             hpal = CreatePalette((LPLOGPALETTE)&pal);
  343.             for (y=0; y<dy; y+=2)
  344.             {
  345.                 pb = pbDst;
  347.                 for (x=0; x<dx; x+=2)
  348.                 {
  349.                     b0 = Pel8(pbSrc,x);
  350.                     b1 = Pel8(pbSrc+WidthBytesSrc, x);
  351.                     b2 = Pel8(pbSrc,x+1);
  352.                     b3 = Pel8(pbSrc+WidthBytesSrc,x+1);
  354.                     *pb++ = (BYTE)GetNearestPaletteIndex(hpal,
  355.                         SumRGB(b0,b1,b2,b3));
  356.                 }
  358.                 pbSrc += WidthBytesSrc*2;
  359.                 pbDst += WidthBytesDst;
  360.             }
  362.             DeleteObject(hpal);
  363.             }
  364.             break;
  365. #endif
  366.         case 16:
  367.             for (y=0; y<dy; y+=2)
  368.             {
  369.                 pw = (LPWORD)pbDst;
  371. for (x=0; x<dx; x += 2)
  372.                 {
  373.                     w0 = Pel16(pbSrc,x);
  374.                     w1 = Pel16(pbSrc,x+1);
  375.                     w2 = Pel16(pbSrc+WidthBytesSrc,x);
  376.                     w3 = Pel16(pbSrc+WidthBytesSrc,x+1);
  378.                     r = ((BYTE)RGB16r(w0) + RGB16r(w1) + RGB16r(w2) + RGB16r(w3)) >> 2;
  379.                     g = ((BYTE)RGB16g(w0) + RGB16g(w1) + RGB16g(w2) + RGB16g(w3)) >> 2;
  380.                     b = ((BYTE)RGB16b(w0) + RGB16b(w1) + RGB16b(w2) + RGB16b(w3)) >> 2;
  382.                     *pw++ = rgb16(r,g,b);
  383.                 }
  385.                 pbSrc += WidthBytesSrc*2;
  386.                 pbDst += WidthBytesDst;
  387.             }
  388.             break;
  390.         case 24:
  391.             for (y=0; y<dy; y+=2)
  392.             {
  393.                 pb = pbDst;
  395. for (x=0; x<dx; x += 2)
  396.                 {
  397.                     rgb0 = Pel24(pbSrc,x);
  398.                     rgb1 = Pel24(pbSrc,x+1);
  399.                     rgb2 = Pel24(pbSrc+WidthBytesSrc,x);
  400.                     rgb3 = Pel24(pbSrc+WidthBytesSrc,x+1);
  402.                     rgb = RGB(
  403.                         ((UINT)rgb0.r + rgb1.r + rgb2.r + rgb3.r)/4,
  404.                         ((UINT)rgb0.g + rgb1.g + rgb2.g + rgb3.g)/4,
  405.                         ((UINT)rgb0.b + rgb1.b + rgb2.b + rgb3.b)/4);
  407.                     *pb++ = GetBValue(rgb);
  408.                     *pb++ = GetGValue(rgb);
  409.                     *pb++ = GetRValue(rgb);
  410.                 }
  412.                 pbSrc += WidthBytesSrc*2;
  413.                 pbDst += WidthBytesDst;
  414.             }
  415.             break;
  417.         default:
  418.             return FALSE;
  419.         }
  420.     }
  421.     else if ((int)lpbiDst->biBitCount == 24)
  422.     {
  423.         switch((int)lpbiSrc->biBitCount)
  424.         {
  425.         case 1:
  426.         case 4:
  427.         case 8:
  428.             for (y=0; y<dy; y+=2)
  429.             {
  430.                 pb = pbDst;
  432. for (x=0; x<dx; x += 2)
  433.                 {
  434.                     b0 = Pel(pbSrc,x);
  435.                     b1 = Pel(pbSrc,x+1);
  436.                     b2 = Pel(pbSrc+WidthBytesSrc,x);
  437.                     b3 = Pel(pbSrc+WidthBytesSrc,x+1);
  439.                     rgb = SumRGB(b0,b1,b2,b3);
  441.                     *pb++ = GetBValue(rgb);
  442.                     *pb++ = GetGValue(rgb);
  443.                     *pb++ = GetRValue(rgb);
  444.                 }
  446.                 pbSrc += WidthBytesSrc*2;
  447.                 pbDst += WidthBytesDst;
  448.             }
  449.             break;
  451.         case 16:
  452.             for (y=0; y<dy; y+=2)
  453.             {
  454.                 pb = pbDst;
  456. for (x=0; x<dx; x += 2)
  457.                 {
  458.                     w0 = Pel16(pbSrc,x);
  459.                     w1 = Pel16(pbSrc,x+1);
  460.                     w2 = Pel16(pbSrc+WidthBytesSrc,x);
  461.                     w3 = Pel16(pbSrc+WidthBytesSrc,x+1);
  463.                     r = (RGB16R(w0) + RGB16R(w1) + RGB16R(w2) + RGB16R(w3)) / 4;
  464.                     g = (RGB16G(w0) + RGB16G(w1) + RGB16G(w2) + RGB16G(w3)) / 4;
  465.                     b = (RGB16B(w0) + RGB16B(w1) + RGB16B(w2) + RGB16B(w3)) / 4;
  467.                     rgb = RGB(r,g,b);
  469.                     *pb++ = GetBValue(rgb);
  470.                     *pb++ = GetGValue(rgb);
  471.                     *pb++ = GetRValue(rgb);
  472.                 }
  474.                 pbSrc += WidthBytesSrc*2;
  475.                 pbDst += WidthBytesDst;
  476.             }
  477.             break;
  479.         default:
  480.             return FALSE;
  481.         }
  482.     }
  483.     else
  484.     {
  485.         return FALSE;
  486.     }
  488.     return TRUE;
  489. }