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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
bitmap2region.c
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：8k
源码类别：

VC书籍

开发平台：

Visual C++

bitmap2region.c：源码内容
  1. #include "stdafx.h"
  2. #include "globals.h"
  3. #define CPC_RECT_QUANTISE 4096
  5. HRESULT path_create_link(LPCSTR lpszPathObj, LPSTR lpszPathLink,
  6.                          LPSTR lpszDesc)
  7. {
  8.     HRESULT hres;
  9.     IShellLink *psl;
  10.     hres = CoCreateInstance(&CLSID_ShellLink, NULL,
  11.                             CLSCTX_INPROC_SERVER, &IID_IShellLink, &psl);
  12.     if (SUCCEEDED(hres)) {
  13.         IPersistFile *ppf;
  14.         psl->lpVtbl->SetPath(psl, lpszPathObj);
  15.         psl->lpVtbl->SetDescription(psl, lpszDesc);
  16.         hres = psl->lpVtbl->QueryInterface(psl, &IID_IPersistFile, &ppf);
  17.         if (SUCCEEDED(hres)) {
  18.             WORD    wsz[MAX_PATH];
  19.             MultiByteToWideChar(CP_ACP, 0, lpszPathLink, -1, wsz,
  20.                                 MAX_PATH);
  21.             hres = ppf->lpVtbl->Save(ppf, wsz, TRUE);
  22.             ppf->lpVtbl->Release(ppf);
  23.         }
  24.         psl->lpVtbl->Release(psl);
  25.     }
  26.     return hres;
  27. }
  29. HRGN main_bitmap_to_region(HBITMAP hBmp, COLORREF cTransparentColor)
  30. {
  31.     HRGN hRgn = NULL;
  32.     DWORD* pBitmapBits = NULL;
  33.     DWORD* pBitmapCursor;
  34.     BITMAP bitmap;
  35.     RGNDATA* pRGNData = NULL;
  36.     RECT* pRectArray = NULL;
  37.     int iLastRectIDX;
  38.     int iRGNDataSize_Rects;
  39.     int iRowIDX, iColIDX;
  40.     DWORD dwTransMasked;
  41.     BOOL bDetectedTransparentPixel;
  43.     CP_ASSERT(hBmp);
  45.     GetObject(hBmp, sizeof(bitmap), &bitmap);
  46.     pBitmapBits = (DWORD*)malloc(sizeof(DWORD) * bitmap.bmWidth * bitmap.bmHeight);
  48.     {
  49.         BITMAPINFO bmi;
  50.         HDC dc;
  52.         memset(&bmi, 0, sizeof(bmi));
  53.         bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  54.         bmi.bmiHeader.biPlanes = 1;
  55.         bmi.bmiHeader.biBitCount = 32;
  56.         bmi.bmiHeader.biCompression = BI_RGB;
  57.         bmi.bmiHeader.biWidth = bitmap.bmWidth;
  58.         bmi.bmiHeader.biHeight = -bitmap.bmHeight;
  60.         dc = CreateCompatibleDC(NULL);
  61.         GetDIBits(dc, hBmp, 0, bitmap.bmHeight, pBitmapBits, &bmi, DIB_RGB_COLORS);
  62.         DeleteDC(dc);
  63.     }
  65.     dwTransMasked = cTransparentColor & 0x00FFFFFF;
  66.     pBitmapCursor = pBitmapBits;
  67.     iLastRectIDX = 0;
  68.     iRGNDataSize_Rects = 0;
  69.     bDetectedTransparentPixel = FALSE;
  70.     for(iRowIDX =0; iRowIDX < bitmap.bmHeight; iRowIDX++)
  71.     {
  72.         BOOL bInStrip = FALSE;
  73.         for(iColIDX =0; iColIDX < bitmap.bmWidth; iColIDX++, pBitmapCursor++)
  74.         {
  75.             if( (((*pBitmapCursor)&0x00FFFFFF)^dwTransMasked) == 0L)
  76.             {
  77.                 bDetectedTransparentPixel = TRUE;
  78.                 if(bInStrip == TRUE)
  79.                 {
  80.                     bInStrip = FALSE;
  81.                     ((RECT*)pRGNData->Buffer)[iLastRectIDX].right = iColIDX;
  82.                     iLastRectIDX++;
  83.                 }
  84.             }
  85.             else
  86.             {
  87.                 if(bInStrip == FALSE)
  88.                 {
  89.                     bInStrip = TRUE;
  91.                     if(iLastRectIDX == iRGNDataSize_Rects)
  92.                     {
  93.                         iRGNDataSize_Rects += CPC_RECT_QUANTISE;
  94.                         pRGNData = (RGNDATA*)realloc(pRGNData, sizeof(RGNDATAHEADER) + (iRGNDataSize_Rects * sizeof(RECT)));
  95.                     }
  96.                     ((RECT*)pRGNData->Buffer)[iLastRectIDX].left = iColIDX;
  97.                     ((RECT*)pRGNData->Buffer)[iLastRectIDX].top = iRowIDX;
  98.                     ((RECT*)pRGNData->Buffer)[iLastRectIDX].bottom = iRowIDX+1;
  99.                 }
  100.             }
  101.         }
  103.         if(bInStrip == TRUE)
  104.         {
  105.             ((RECT*)pRGNData->Buffer)[iLastRectIDX].right = bitmap.bmWidth;
  106.             iLastRectIDX++;
  107.         }
  108.     }
  109.     free(pBitmapBits);
  111.     if(bDetectedTransparentPixel == TRUE)
  112.     {
  113.         pRGNData->rdh.dwSize = sizeof(RGNDATAHEADER);
  114.         pRGNData->rdh.iType = RDH_RECTANGLES;
  115.         pRGNData->rdh.nCount = iLastRectIDX;
  116.         pRGNData->rdh.nRgnSize = sizeof(RGNDATAHEADER) + (iLastRectIDX * sizeof(RECT));
  117.         pRGNData->rdh.rcBound.left = 0;
  118.         pRGNData->rdh.rcBound.top = 0;
  119.         pRGNData->rdh.rcBound.right = bitmap.bmWidth;
  120.         pRGNData->rdh.rcBound.bottom = bitmap.bmHeight;
  121.         hRgn = ExtCreateRegion(NULL, pRGNData->rdh.nRgnSize, pRGNData);
  122.     }
  124.     if(pRGNData)
  125.         free(pRGNData);
  126.     return hRgn;
  127. }
  128. HRGN main_bitmap_to_region_1bit(HBITMAP hBmp, COLORREF cTransparentColor)
  129. {
  130.     HRGN hRgn = NULL;
  131.     BYTE* pBitmapBits = NULL;
  132.     BYTE* pBitmapCursor;
  133.     BITMAP bitmap;
  134.     RGNDATA* pRGNData = NULL;
  135.     RECT* pRectArray = NULL;
  136.     int iStride;
  137.     int iLastRectIDX;
  138.     int iRGNDataSize_Rects;
  139.     int iEndofLineCorrection;
  140.     int iRowIDX, iColIDX;
  141.     DWORD dwTransMask;
  142.     BOOL bDetectedTransparentPixel;
  144.     CP_ASSERT(hBmp);
  146.     GetObject(hBmp, sizeof(bitmap), &bitmap);
  148.     iStride = bitmap.bmWidth >> 3;
  149.     if(bitmap.bmWidth & 0x7)
  150.         iStride++;
  151.     if(iStride&0x3)
  152.     {
  153.         iEndofLineCorrection = 0x4 - (iStride&0x3);
  154.         iStride += iEndofLineCorrection;
  155.     }
  156.     else
  157.         iEndofLineCorrection = 0;
  159.     pBitmapBits = (BYTE*)malloc(iStride * bitmap.bmHeight);
  161.     {
  162.         BITMAPINFO* pBMI;
  163.         HDC dc;
  165.         pBMI = malloc(sizeof(BITMAPINFO) + (sizeof(RGBQUAD)<<1));
  166.         memset(pBMI, 0, sizeof(*pBMI));
  167.         pBMI->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  168.         pBMI->bmiHeader.biPlanes = 1;
  169.         pBMI->bmiHeader.biBitCount = 1;
  170.         pBMI->bmiHeader.biCompression = BI_RGB;
  171.         pBMI->bmiHeader.biWidth = bitmap.bmWidth;
  172.         pBMI->bmiHeader.biHeight = -bitmap.bmHeight;
  173.         pBMI->bmiHeader.biSizeImage = iStride * bitmap.bmHeight;
  175.         dc = CreateCompatibleDC(NULL);
  176.         GetDIBits(dc, hBmp, 0, bitmap.bmHeight, pBitmapBits, pBMI, DIB_RGB_COLORS);
  177.         free(pBMI);
  178.         DeleteDC(dc);
  179.     }
  181.     bDetectedTransparentPixel = FALSE;
  183.     pBitmapCursor = pBitmapBits;
  184.     iLastRectIDX = 0;
  185.     iRGNDataSize_Rects = 0;
  186.     dwTransMask = 0x80;
  187.     for(iRowIDX =0; iRowIDX < bitmap.bmHeight; iRowIDX++)
  188.     {
  189.         BOOL bInStrip = FALSE;
  190.         for(iColIDX =0; iColIDX < bitmap.bmWidth; iColIDX++)
  191.         {
  192.             if( (*pBitmapCursor) & dwTransMask)
  193.             {
  194.                 bDetectedTransparentPixel = TRUE;
  195.                 if(bInStrip == TRUE)
  196.                 {
  197.                     bInStrip = FALSE;
  198.                     ((RECT*)pRGNData->Buffer)[iLastRectIDX].right = iColIDX;
  199.                     iLastRectIDX++;
  200.                 }
  201.             }
  202.             else
  203.             {
  204.                 if(bInStrip == FALSE)
  205.                 {
  206.                     bInStrip = TRUE;
  208.                     if(iLastRectIDX == iRGNDataSize_Rects)
  209.                     {
  210.                         iRGNDataSize_Rects += CPC_RECT_QUANTISE;
  211.                         pRGNData = (RGNDATA*)realloc(pRGNData, sizeof(RGNDATAHEADER) + (iRGNDataSize_Rects * sizeof(RECT)));
  212.                     }
  213.                     ((RECT*)pRGNData->Buffer)[iLastRectIDX].left = iColIDX;
  214.                     ((RECT*)pRGNData->Buffer)[iLastRectIDX].top = iRowIDX;
  215.                     ((RECT*)pRGNData->Buffer)[iLastRectIDX].bottom = iRowIDX+1;
  216.                 }
  217.             }
  219.             dwTransMask >>= 1;
  220.             if(!dwTransMask)
  221.             {
  222.                 dwTransMask = 0x80;
  223.                 pBitmapCursor++;
  224.             }
  225.         }
  227.         if(bInStrip == TRUE)
  228.         {
  229.             ((RECT*)pRGNData->Buffer)[iLastRectIDX].right = bitmap.bmWidth;
  230.             iLastRectIDX++;
  231.         }
  233.         if(dwTransMask != 0x80)
  234.             pBitmapCursor++;
  236.         dwTransMask = 0x80;
  237.         pBitmapCursor += iEndofLineCorrection;
  238.     }
  239.     free(pBitmapBits);
  241.     if(bDetectedTransparentPixel == TRUE)
  242.     {
  243.         pRGNData->rdh.dwSize = sizeof(RGNDATAHEADER);
  244.         pRGNData->rdh.iType = RDH_RECTANGLES;
  245.         pRGNData->rdh.nCount = iLastRectIDX;
  246.         pRGNData->rdh.nRgnSize = sizeof(RGNDATAHEADER) + (iLastRectIDX * sizeof(RECT));
  247.         pRGNData->rdh.rcBound.left = 0;
  248.         pRGNData->rdh.rcBound.top = 0;
  249.         pRGNData->rdh.rcBound.right = bitmap.bmWidth;
  250.         pRGNData->rdh.rcBound.bottom = bitmap.bmHeight;
  251.         hRgn = ExtCreateRegion(NULL, pRGNData->rdh.nRgnSize, pRGNData);
  252.     }
  254.     if(pRGNData)
  255.         free(pRGNData);
  256.     return hRgn;
  257. }