Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
thumnail.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 16k
Category:

Windows Kernel

Development Platform:

Visual C++

thumnail.cpp：Code Content
  1. #include "thlibpch.h"
  3. CThumbnailMaker::CThumbnailMaker()
  4. {
  5.     pImH = NULL;
  7. }
  9. CThumbnailMaker::~CThumbnailMaker()
  10. {
  11.     if (pImH)
  12.         delete[] pImH;
  13. }
  16. STDMETHODIMP
  17. CThumbnailMaker::Init( UINT uiDstWidth_,
  18.                        UINT uiDstHeight_,
  19.                        UINT uiSrcWidth_,
  20.                        UINT uiSrcHeight_ )
  21. {
  22.     uiDstWidth = uiDstWidth_;
  23.     uiDstHeight = uiDstHeight_;
  24.     uiSrcWidth = uiSrcWidth_;
  25.     uiSrcHeight = uiSrcHeight_;
  27.     if (uiDstWidth < 1 || uiDstHeight < 1 ||
  28.         uiSrcWidth < 1 || uiSrcHeight < 1)
  29.         return E_INVALIDARG;
  31.     if (pImH)
  32.         delete[] pImH;
  34.     pImH = new BGR3[uiDstWidth * uiSrcHeight];
  35.     if (pImH == NULL)
  36.         return E_OUTOFMEMORY;
  38.     return S_OK;
  39. }
  41. void
  42. CThumbnailMaker::Scale( BGR3 *pucDst,
  43.                         UINT uiDstWidth,
  44.                         int iDstBytStep,
  45.                         BGR3 *pucSrc,
  46.                         UINT uiSrcWidth,
  47.                         int iSrcBytStep )
  48. {
  49.     UINT uiDstX;
  50.     int frac, mnum, mden;
  52.     mnum = uiSrcWidth;
  53.     mden = uiDstWidth;
  55.     //
  56.     // Scaling up, use a triangle filter.
  57.     //
  58.     if (mden >= mnum)
  59.     {
  60.         BGR3 *pucSrc1;
  62.         frac = 0;
  64.         //
  65.         // Adjust the slope so that we calculate the fraction of the
  66.         // "next" pixel to use (i.e. should be 0 for the first and
  67.         // last dst pixel).
  68.         //
  69.         --mnum;
  70.         if (--mden == 0)
  71.             mden = 0; // avoid div by 0
  73.         pucSrc1 = (BGR3 *)(((UCHAR *)pucSrc) + iSrcBytStep);
  75.         for (uiDstX = 0; uiDstX < uiDstWidth; ++uiDstX)
  76.         {
  77.             if (frac == 0)
  78.             {
  79.                 (*pucDst)[0] = (*pucSrc)[0];
  80.                 (*pucDst)[1] = (*pucSrc)[1];
  81.                 (*pucDst)[2] = (*pucSrc)[2];
  82.             }
  83.             else
  84.             {
  85.                 (*pucDst)[0] =
  86.                     ((mden - frac) * (*pucSrc)[0] +
  87.                      frac * (*pucSrc1)[0]) / mden;
  88.                 (*pucDst)[1] =
  89.                     ((mden - frac) * (*pucSrc)[1] +
  90.                      frac * (*pucSrc1)[1]) / mden;
  91.                 (*pucDst)[2] =
  92.                     ((mden - frac) * (*pucSrc)[2] +
  93.                      frac * (*pucSrc1)[2]) / mden;
  94.             }
  96.             pucDst = (BGR3 *)((UCHAR *)pucDst + iDstBytStep);
  98.             frac += mnum;
  99.             if (frac >= mden)
  100.             {
  101.                 frac -= mden;
  102.                 pucSrc = (BGR3 *)((UCHAR *)pucSrc +
  103.                           iSrcBytStep);
  104.                 pucSrc1 = (BGR3 *)((UCHAR *)pucSrc1 +
  105.                            iSrcBytStep);
  106.             }
  107.         }
  108.     }
  110.     //
  111.     // Scaling down, use a box filter.
  112.     //
  113.     else
  114.     {
  115.         frac = 0;
  117.         for (uiDstX = 0; uiDstX < uiDstWidth; ++uiDstX)
  118.         {
  119.             UINT uiSum[3];
  120.             UINT uiCnt;
  122.             uiSum[0] = uiSum[1] = uiSum[2] = 0;
  123.             uiCnt = 0;
  125.             frac += mnum;
  126.             while (frac >= mden)
  127.             {
  128.                 uiSum[0] += (*pucSrc)[0];
  129.                 uiSum[1] += (*pucSrc)[1];
  130.                 uiSum[2] += (*pucSrc)[2];
  131.                 ++uiCnt;
  133.                 frac -= mden;
  134.                 pucSrc = (BGR3 *)((UCHAR *)pucSrc +
  135.                           iSrcBytStep);
  136.             }
  138.             (*pucDst)[0] = uiSum[0] / uiCnt;
  139.             (*pucDst)[1] = uiSum[1] / uiCnt;
  140.             (*pucDst)[2] = uiSum[2] / uiCnt;
  142.             pucDst = (BGR3 *)((UCHAR *)pucDst + iDstBytStep);
  143.         }
  144.     }
  145. }
  147. //
  148. // For AddScanline, we scale the input horizontally into our temporary
  149. // image buffer.
  150. //
  151. STDMETHODIMP
  152. CThumbnailMaker::AddScanline( UCHAR *pucSrc,
  153.                               UINT uiY )
  154. {
  155.     if (pucSrc == NULL || uiY >= uiSrcHeight)
  156.         return E_INVALIDARG;
  158.     Scale(pImH + uiY * uiDstWidth, uiDstWidth, sizeof(BGR3),
  159.           (BGR3 *)pucSrc, uiSrcWidth, sizeof(BGR3));
  161.     return S_OK;
  162. }
  164. //
  165. // For GetBITMAPINFO, we complete the scaling vertically and return the
  166. // result as a DIB.
  167. //
  168. STDMETHODIMP
  169. CThumbnailMaker::GetBITMAPINFO( BITMAPINFO **ppBMInfo,
  170.                                 DWORD *pdwSize )
  171. {
  172.     BITMAPINFO *pBMI;
  173.     BITMAPINFOHEADER *pBMIH;
  174.     DWORD dwBPL, dwTotSize;
  175.     UCHAR *pDst;
  176.     UINT uiDstX;
  178.     if (ppBMInfo == NULL)
  179.         return E_INVALIDARG;
  181.     *ppBMInfo = NULL;
  183.     dwBPL = (((uiDstWidth * 24) + 31) >> 3) & ~3;
  184.     dwTotSize = sizeof(BITMAPINFOHEADER) + dwBPL * uiDstHeight;
  186.     pBMI = (BITMAPINFO *)CoTaskMemAlloc(dwTotSize);
  187.     if (pBMI == NULL)
  188.         return E_OUTOFMEMORY;
  190.     pBMIH = &pBMI->bmiHeader;
  191.     pBMIH->biSize = sizeof(BITMAPINFOHEADER);
  192.     pBMIH->biWidth = uiDstWidth;
  193.     pBMIH->biHeight = uiDstHeight;
  194.     pBMIH->biPlanes = 1;
  195.     pBMIH->biBitCount = 24;
  196.     pBMIH->biCompression = BI_RGB;
  197.     pBMIH->biXPelsPerMeter = 0;
  198.     pBMIH->biYPelsPerMeter = 0;
  199.     pBMIH->biSizeImage = dwBPL * uiDstHeight;
  200.     pBMIH->biClrUsed = 0;
  201.     pBMIH->biClrImportant = 0;
  203.     pDst = (UCHAR *)pBMIH + pBMIH->biSize + (uiDstHeight - 1) * dwBPL;
  205.     for (uiDstX = 0; uiDstX < uiDstWidth; ++uiDstX)
  206.     {
  207.         Scale((BGR3 *)pDst + uiDstX, uiDstHeight, -(int)dwBPL,
  208.               pImH + uiDstX, uiSrcHeight, uiDstWidth * sizeof(BGR3));
  209.     }
  211.     *ppBMInfo = pBMI;
  213.     if (pdwSize)
  214.         *pdwSize = dwTotSize;
  216.     return S_OK;
  217. }
  219. STDMETHODIMP
  220. CThumbnailMaker::GetSharpenedBITMAPINFO( UINT uiSharpPct,
  221.                                          BITMAPINFO **ppBMInfo,
  222.                                          DWORD *pdwSize )
  223. {
  224.     BITMAPINFO *pBMISrc;
  225.     HRESULT hr;
  226.     DWORD dwSize;
  227.     int bpl;
  228.     int x, y, wdiag, wadj, wcent;
  229. #define SCALE 10000
  230.     UCHAR *pucDst, *pucSrc[3];
  232.     if (uiSharpPct > 100)
  233.         return E_INVALIDARG;
  235.     //
  236.     // Get the unsharpened bitmap.
  237.     //
  238.     hr = GetBITMAPINFO(ppBMInfo, &dwSize);
  239.     if (FAILED(hr))
  240.         return hr;
  242.     if (pdwSize)
  243.         *pdwSize = dwSize;
  245.     //
  246.     // Create a duplicate to serve as the original.
  247.     //
  248.     pBMISrc = (BITMAPINFO *)new UCHAR[dwSize];
  249.     if (pBMISrc == NULL)
  250.     {
  251.         delete *ppBMInfo;
  252.         return E_OUTOFMEMORY;
  253.     }
  254.     memcpy(pBMISrc, *ppBMInfo, dwSize);
  256.     bpl = (pBMISrc->bmiHeader.biWidth * 3 + 3) & ~3;
  258.     //
  259.     // Sharpen inside a 1 pixel border
  260.     //
  261.     pucDst = (UCHAR *)*ppBMInfo + sizeof(BITMAPINFOHEADER);
  262.     pucSrc[0] = (UCHAR *)pBMISrc + sizeof(BITMAPINFOHEADER);
  263.     pucSrc[1] = pucSrc[0] + bpl;
  264.     pucSrc[2] = pucSrc[1] + bpl;
  266.     wdiag = (10355 * uiSharpPct) / 100;
  267.     wadj = (14645 * uiSharpPct) / 100;
  268.     wcent = 4 * (wdiag + wadj);
  270.     for (y = 1; y < pBMISrc->bmiHeader.biHeight-1; ++y)
  271.     {
  272.         for (x = 3*(pBMISrc->bmiHeader.biWidth-2); x >= 3; --x)
  273.         {
  274.             int v;
  276.             v = pucDst[x] +
  277.                 (pucSrc[1][x] * wcent -
  278.                  ((pucSrc[0][x - 3] +
  279.                    pucSrc[0][x + 3] +
  280.                    pucSrc[2][x - 3] +
  281.                    pucSrc[2][x + 3]) * wdiag +
  282.                   (pucSrc[0][x] +
  283.                    pucSrc[1][x - 3] +
  284.                    pucSrc[1][x + 3] +
  285.                    pucSrc[2][x]) * wadj)) / SCALE;
  287.             pucDst[x] = v < 0 ? 0 : v > 255 ? 255 : v;
  288.         }
  290.         pucDst += bpl;
  291.         pucSrc[0] = pucSrc[1];
  292.         pucSrc[1] = pucSrc[2];
  293.         pucSrc[2] += bpl;
  294.     }
  296.     delete[] pBMISrc;
  298.     return S_OK;
  299. #undef SCALE
  300. }
  302. HRESULT ThumbnailMaker_Create( IThumbnailMaker **ppThumbMaker )
  303. {
  304.     HRESULT hr;
  305.     CThumbnailMaker *pCThumbMaker;
  307.     if (ppThumbMaker == NULL)
  308.         return E_UNEXPECTED;
  310.     hr = S_OK;
  312.     pCThumbMaker = new CComObject<CThumbnailMaker>;
  313.     if (pCThumbMaker == NULL || FAILED(hr))
  314.     {
  315.         if (pCThumbMaker)
  316.             delete pCThumbMaker;
  317.         else
  318.             hr = E_OUTOFMEMORY;
  319.             
  320.         *ppThumbMaker = NULL;
  322.         return hr;
  323.     }
  325.     *ppThumbMaker = (IThumbnailMaker *) pCThumbMaker;
  326.     pCThumbMaker->AddRef();
  328.     return S_OK;
  329. }
  331. STDMETHODIMP CThumbnailMaker::AddDIB(BITMAPINFO *pBMI)
  332. {
  333.     UCHAR * pBits;
  334.     int ncolors;
  335.     
  336.     ncolors = pBMI->bmiHeader.biClrUsed;
  337.     if (ncolors == 0 && pBMI->bmiHeader.biBitCount <= 8)
  338.         ncolors = 1 << pBMI->bmiHeader.biBitCount;
  339.         
  340.     if (pBMI->bmiHeader.biBitCount == 16 ||
  341.         pBMI->bmiHeader.biBitCount == 32)
  342.     {
  343.         if (pBMI->bmiHeader.biCompression == BI_BITFIELDS)
  344.         {
  345.             ncolors = 3;
  346.         }
  347.     }
  349.     pBits = (UCHAR *)&pBMI->bmiColors[0] + ncolors * sizeof(RGBQUAD);
  351.     return AddDIBSECTION( pBMI, (LPVOID) pBits );
  352. }
  354. STDMETHODIMP CThumbnailMaker::AddDIBSECTION ( BITMAPINFO * pBMI, LPVOID pBits )
  355. {
  356.     RGBQUAD *pRGBQ, *pQ;
  357.     UCHAR *pucBits0, *pucBits, *pB, *pucBits240, *pucBits24, *pB24;
  358.     int bpl;
  359.     int x, y, ncolors;
  360.     ULONG rmask, gmask, bmask;
  361.     int rshift, gshift, bshift;
  362.     HRESULT hr;
  364.     //
  365.     // Make sure that thumbnail maker has been properly initialized.
  366.     //
  367.     if (pBMI == NULL)
  368.         return E_INVALIDARG;
  370.     if (pBMI->bmiHeader.biWidth != (LONG)uiSrcWidth ||
  371.         pBMI->bmiHeader.biHeight != (LONG)uiSrcHeight)
  372.         return E_INVALIDARG;
  374.     //
  375.     // Don't handle RLE.
  376.     //
  377.     if (pBMI->bmiHeader.biCompression != BI_RGB &&
  378.         pBMI->bmiHeader.biCompression != BI_BITFIELDS)
  379.         return E_INVALIDARG;
  381.     pRGBQ = (RGBQUAD *)&pBMI->bmiColors[0];
  383.     ncolors = pBMI->bmiHeader.biClrUsed;
  384.     if (ncolors == 0 && pBMI->bmiHeader.biBitCount <= 8)
  385.         ncolors = 1 << pBMI->bmiHeader.biBitCount;
  387.     //
  388.     // Decode 16/32bpp with masks.
  389.     //
  390.     if (pBMI->bmiHeader.biBitCount == 16 ||
  391.         pBMI->bmiHeader.biBitCount == 32)
  392.     {
  393.         if (pBMI->bmiHeader.biCompression == BI_BITFIELDS)
  394.         {
  395.             rmask = ((ULONG *)pRGBQ)[0];
  396.             gmask = ((ULONG *)pRGBQ)[1];
  397.             bmask = ((ULONG *)pRGBQ)[2];
  398.             ncolors = 3;
  399.         }
  400.         else if (pBMI->bmiHeader.biBitCount == 16)
  401.         {
  402.             rmask = 0x7c00;
  403.             gmask = 0x03e0;
  404.             bmask = 0x001f;
  405.         }
  406.         else /* 32 */
  407.         {
  408.             rmask = 0xff0000;
  409.             gmask = 0x00ff00;
  410.             bmask = 0x0000ff;
  411.         }
  413.         for (rshift = 0; (rmask & 1) == 0; rmask >>= 1, ++rshift);
  414.         if (rmask == 0)
  415.             rmask = 1;
  416.         for (gshift = 0; (gmask & 1) == 0; gmask >>= 1, ++gshift);
  417.         if (gmask == 0)
  418.             gmask = 1;
  419.         for (bshift = 0; (bmask & 1) == 0; bmask >>= 1, ++bshift);
  420.         if (bmask == 0)
  421.             bmask = 1;
  422.     }
  424.     bpl = ((pBMI->bmiHeader.biBitCount * uiSrcWidth + 31) >> 3) & ~3;
  426.     pucBits0 = (UCHAR *) pBits;
  427.     pucBits = pucBits0;
  429.     if (pBMI->bmiHeader.biBitCount == 24)
  430.         pucBits240 = pucBits;
  431.     else
  432.     {
  433.         int bpl24 = (uiSrcWidth * 3 + 3) & ~3;
  435.         pucBits240 = new UCHAR[bpl24];
  436.         if (pucBits240 == NULL)
  437.             return E_OUTOFMEMORY;
  438.     }
  439.     pucBits24 = pucBits240;
  441.     hr = S_OK;
  443.     for (y = 0; y < (int)uiSrcHeight; ++y)
  444.     {
  445.         pB = pucBits;
  446.         pB24 = pucBits24;
  448.         switch (pBMI->bmiHeader.biBitCount)
  449.         {
  450.         case 1:
  451.             for (x = uiSrcWidth; x >= 8; x -= 8)
  452.             {
  453.                 pQ = &pRGBQ[(*pB >> 7) & 1];
  454.                 *pB24++ = pQ->rgbBlue;
  455.                 *pB24++ = pQ->rgbGreen;
  456.                 *pB24++ = pQ->rgbRed;
  458.                 pQ = &pRGBQ[(*pB >> 6) & 1];
  459.                 *pB24++ = pQ->rgbBlue;
  460.                 *pB24++ = pQ->rgbGreen;
  461.                 *pB24++ = pQ->rgbRed;
  463.                 pQ = &pRGBQ[(*pB >> 5) & 1];
  464.                 *pB24++ = pQ->rgbBlue;
  465.                 *pB24++ = pQ->rgbGreen;
  466.                 *pB24++ = pQ->rgbRed;
  468.                 pQ = &pRGBQ[(*pB >> 4) & 1];
  469.                 *pB24++ = pQ->rgbBlue;
  470.                 *pB24++ = pQ->rgbGreen;
  471.                 *pB24++ = pQ->rgbRed;
  473.                 pQ = &pRGBQ[(*pB >> 3) & 1];
  474.                 *pB24++ = pQ->rgbBlue;
  475.                 *pB24++ = pQ->rgbGreen;
  476.                 *pB24++ = pQ->rgbRed;
  478.                 pQ = &pRGBQ[(*pB >> 2) & 1];
  479.                 *pB24++ = pQ->rgbBlue;
  480.                 *pB24++ = pQ->rgbGreen;
  481.                 *pB24++ = pQ->rgbRed;
  483.                 pQ = &pRGBQ[(*pB >> 1) & 1];
  484.                 *pB24++ = pQ->rgbBlue;
  485.                 *pB24++ = pQ->rgbGreen;
  486.                 *pB24++ = pQ->rgbRed;
  488.                 pQ = &pRGBQ[(*pB++) & 1];
  489.                 *pB24++ = pQ->rgbBlue;
  490.                 *pB24++ = pQ->rgbGreen;
  491.                 *pB24++ = pQ->rgbRed;
  492.             }
  494.             if (x > 0)
  495.             {
  496.                 int shf = 8;
  498.                 do
  499.                 {
  500.                     pQ = &pRGBQ[(*pB >> --shf) & 1];
  501.                     *pB24++ = pQ->rgbBlue;
  502.                     *pB24++ = pQ->rgbGreen;
  503.                     *pB24++ = pQ->rgbRed;
  504.                 }
  505.                 while (--x);
  506.             }
  508.             break;
  510.         case 4:
  511.             for (x = uiSrcWidth; x >= 2; x -= 2)
  512.             {
  513.                 pQ = &pRGBQ[(*pB >> 4) & 0xf];
  514.                 *pB24++ = pQ->rgbBlue;
  515.                 *pB24++ = pQ->rgbGreen;
  516.                 *pB24++ = pQ->rgbRed;
  518.                 pQ = &pRGBQ[*pB++ & 0xf];
  519.                 *pB24++ = pQ->rgbBlue;
  520.                 *pB24++ = pQ->rgbGreen;
  521.                 *pB24++ = pQ->rgbRed;
  522.             }
  524.             if (x > 0)
  525.             {
  526.                 pQ = &pRGBQ[(*pB >> 4) & 0xf];
  527.                 *pB24++ = pQ->rgbBlue;
  528.                 *pB24++ = pQ->rgbGreen;
  529.                 *pB24++ = pQ->rgbRed;
  531.                 if (x > 1)
  532.                 {
  533.                     pQ = &pRGBQ[*pB & 0xf];
  534.                     *pB24++ = pQ->rgbBlue;
  535.                     *pB24++ = pQ->rgbGreen;
  536.                     *pB24++ = pQ->rgbRed;
  537.                 }
  538.             }
  540.             break;
  542.         case 8:
  543.             for (x = uiSrcWidth; x--; )
  544.             {
  545.                 pQ = &pRGBQ[*pB++];
  546.                 *pB24++ = pQ->rgbBlue;
  547.                 *pB24++ = pQ->rgbGreen;
  548.                 *pB24++ = pQ->rgbRed;
  549.             }
  551.             break;
  553.         case 16:
  554.         {
  555.             USHORT *pW;
  557.             pW = (USHORT *)pucBits;
  559.             for (x = uiSrcWidth; x--; )
  560.             {
  561.                 ULONG w = *pW++;
  563.                 *pB24++ = (UCHAR)
  564.                      ((((w >> bshift) & bmask) * 255) / bmask);
  565.                 *pB24++ = (UCHAR)
  566.                      ((((w >> gshift) & gmask) * 255) / gmask);
  567.                 *pB24++ = (UCHAR)
  568.                      ((((w >> rshift) & rmask) * 255) / rmask);
  569.             }
  571.             break;
  572.         }
  574.         case 24:
  575.             pucBits24 = pucBits;
  576.             break;
  578.         case 32:
  579.         {
  580.             ULONG *pD;
  582.             pD = (ULONG *)pucBits;
  584.             for (x = uiSrcWidth; x--; )
  585.             {
  586.                 ULONG d = *pD++;
  588.                 *pB24++ = (UCHAR)
  589.                      ((((d >> bshift) & bmask) * 255) / bmask);
  590.                 *pB24++ = (UCHAR)
  591.                      ((((d >> gshift) & gmask) * 255) / gmask);
  592.                 *pB24++ = (UCHAR)
  593.                      ((((d >> rshift) & rmask) * 255) / rmask);
  594.             }
  596.             break;
  597.         }
  599.         default:
  600.             delete[] pucBits24;
  601.             return E_INVALIDARG;
  602.         }
  604.         hr = AddScanline(pucBits24, (uiSrcHeight-1) - y);
  605.         if (FAILED(hr))
  606.             break;
  608.         pucBits += bpl;
  609.     }
  611.     if (pucBits240 != pucBits0)
  612.         delete[] pucBits240;
  614.     return hr;
  615. }