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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
pximage.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：75k
源码类别：

Symbian

开发平台：

C/C++

pximage.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. // include
  37. #include "hxtypes.h"
  38. #include "hxwintyp.h"
  39. #include "hxresult.h"
  40. #include "hxcom.h"
  41. #include "ihxpckts.h"
  42. #include "hxvsurf.h"
  44. // hxcont
  45. #include "hxbuffer.h"
  47. // hxmisc
  48. #include "unkimp.h"
  49. #include "baseobj.h"
  51. // pxcomlib
  52. #include "pxcolor.h"
  53. #include "pxrect.h"
  54. #include "pxeffect.h"
  55. #include "pximage.h"
  57. // hxdebug
  58. #include "hxheap.h"
  59. #ifdef _DEBUG
  60. #undef HX_THIS_FILE
  61. static char HX_THIS_FILE[] = __FILE__;
  62. #endif
  64. PXImage::PXImage()
  65. {
  66.     ResetMembers();
  67.     m_lRefCount   = 0;
  68.     m_pImageStore = NULL;
  69. }
  71. PXImage::~PXImage()
  72. {
  73.     Destroy();
  74. }
  76. HX_RESULT PXImage::CreateObject(PXImage** ppImg)
  77. {
  78.     HX_RESULT retVal = HXR_FAIL;
  80.     if (ppImg)
  81.     {
  82.         PXImage* pImg = new PXImage();
  83.         if (pImg)
  84.         {
  85.             *ppImg = pImg;
  86.             retVal = HXR_OK;
  87.         }
  88.     }
  90.     return retVal;
  91. }
  93. HX_RESULT PXImage::CreateInstance(PXImage** ppImg)
  94. {
  95.     HX_RESULT retVal = HXR_FAIL;
  97.     if (ppImg)
  98.     {
  99.         PXImage* pImg = new PXImage();
  100.         if (pImg)
  101.         {
  102.             // AddRef the object
  103.             pImg->AddRef();
  104.             // Assign the out parameter
  105.             *ppImg = pImg;
  106.             retVal = HXR_OK;
  107.         }
  108.     }
  110.     return retVal;
  111. }
  113. STDMETHODIMP PXImage::QueryInterface(REFIID riid, void** ppvObj)
  114. {
  115.     HX_RESULT retVal = HXR_OK;
  117.     if (IsEqualIID(riid, IID_IUnknown))
  118.     {
  119.         AddRef();
  120.         *ppvObj = (IUnknown *) this;
  121.     }
  122.     else
  123.     {
  124.         *ppvObj = NULL;
  125.         retVal  = HXR_NOINTERFACE;
  126.     }
  128.     return retVal;
  129. }
  131. STDMETHODIMP_(UINT32) PXImage::AddRef()
  132. {
  133.     return InterlockedIncrement(&m_lRefCount);
  134. }
  136. STDMETHODIMP_(UINT32) PXImage::Release()
  137. {
  138.     
  139.     if (InterlockedDecrement(&m_lRefCount) > 0)
  140.         return m_lRefCount;
  142.     delete this;
  144.     return 0;
  145. }
  147. HX_RESULT PXImage::Create(INT32 lW, INT32 lH, UINT32 ulBpp, UINT32 ulFormat,
  148.                           BOOL bRowsInverted, BOOL bAlloc)
  149. {
  150.     // Check for invalid input size
  151.     if (lW <= 0          ||
  152.         lW >  kMaxWidth  ||
  153.         lH <= 0          ||
  154.         lH >  kMaxHeight)
  155.     {
  156.         HX_ASSERT(FALSE);
  157.         return HXR_FAIL;
  158.     }
  160.     // Check to see if we're asked to NOT alloc, but
  161.     // don't have any image store
  162.     if (!bAlloc && !m_pImageStore)
  163.     {
  164.         HX_ASSERT(FALSE);
  165.         return HXR_FAIL;
  166.     }
  168.     // Filter out unsupported formats
  169.     switch (ulBpp)
  170.     {
  171.         case 32:
  172.             if (ulFormat != HX_RGB)
  173.             {
  174.                 HX_ASSERT(FALSE);
  175.                 return HXR_FAIL;
  176.             }
  177.             break;
  178.         default:
  179.             HX_ASSERT(FALSE);
  180.             return HXR_FAIL;
  181.     }
  183.     // Reset members (except image store)
  184.     ResetMembers();
  186.     // Assign member variables
  187.     m_cBitmapInfo.biWidth       = lW;
  188.     m_cBitmapInfo.biHeight      = lH;
  189.     m_cBitmapInfo.biBitCount    = (UINT16) ulBpp;
  190.     m_cBitmapInfo.biCompression = ulFormat;
  191.     m_cSubImageRect.left        = 0;
  192.     m_cSubImageRect.top         = 0;
  193.     m_cSubImageRect.right       = lW;
  194.     m_cSubImageRect.bottom      = lH;
  195.     m_lSubImageWidth            = lW;
  196.     m_lSubImageHeight           = lH;
  197.     m_bRowsInverted             = bRowsInverted;
  198.     m_ulBytesPerPixel           = (ulBpp + 7) >> 3;
  199.     m_lRowBytes                 = lW * m_ulBytesPerPixel;
  200.     m_lRowStride                = (m_lRowBytes + 3) & ~3;
  202.     // Determine the number of bytes we need
  203.     UINT32 ulNumBytes = m_lRowStride * m_cBitmapInfo.biHeight;
  205.     // Check to see if we need to alloc memory. We will allocate
  206.     // if the bAlloc parameter tells us to OR if bAlloc is FALSE
  207.     // AND we have don't already have enough to satisfy the request.
  208.     if (bAlloc || (!bAlloc && m_pImageStore->GetSize() < ulNumBytes))
  209.     {
  210.         // Now create the storage object
  211.         HX_RELEASE(m_pImageStore);
  212.         m_pImageStore = (IHXBuffer *) new CHXBuffer();
  213.         if (!m_pImageStore)
  214.         {
  215.             ResetMembers();
  216.             return HXR_OUTOFMEMORY;
  217.         }
  218.         m_pImageStore->AddRef();
  220.         // Set its size
  221.         HX_RESULT retVal = m_pImageStore->SetSize(ulNumBytes);
  222.         if (retVal != HXR_OK)
  223.         {
  224.             HX_RELEASE(m_pImageStore);
  225.             ResetMembers();
  226.             return retVal;
  227.         }
  228.     }
  230.     // Set the image buffer to beginning of storage
  231.     if (m_bRowsInverted)
  232.     {
  233.         m_pImageBuffer = m_pImageStore->GetBuffer() + (m_cBitmapInfo.biHeight - 1) * m_lRowStride;
  234.         m_lRowJump     = - m_lRowStride;
  235.     }
  236.     else
  237.     {
  238.         m_pImageBuffer = m_pImageStore->GetBuffer();
  239.         m_lRowJump     = m_lRowStride;
  240.     }
  242.     // Set the initialization flag
  243.     m_bInitialized = TRUE;
  245.     return HXR_OK;
  246. }
  248. HX_RESULT PXImage::CreateFromBuffer(INT32 lW, INT32 lH, UINT32 ulBpp, UINT32 ulFormat,
  249.                                     BOOL bRowsInverted, IHXBuffer* pBuffer)
  250. {
  251.     HX_RESULT retVal = HXR_OK;
  253.     if (lW > 0 && lW <= kMaxWidth && lH > 0 && lH <= kMaxHeight &&
  254.         ulBpp == 32 && ulFormat == HX_RGB && pBuffer)
  255.     {
  256.         // Reset members (except image store)
  257.         ResetMembers();
  259.         // Assign member variables
  260.         m_cBitmapInfo.biWidth       = lW;
  261.         m_cBitmapInfo.biHeight      = lH;
  262.         m_cBitmapInfo.biBitCount    = (UINT16) ulBpp;
  263.         m_cBitmapInfo.biCompression = ulFormat;
  264.         m_cSubImageRect.left        = 0;
  265.         m_cSubImageRect.top         = 0;
  266.         m_cSubImageRect.right       = lW;
  267.         m_cSubImageRect.bottom      = lH;
  268.         m_lSubImageWidth            = lW;
  269.         m_lSubImageHeight           = lH;
  270.         m_bRowsInverted             = bRowsInverted;
  271.         m_ulBytesPerPixel           = (ulBpp + 7) >> 3;
  272.         m_lRowBytes                 = lW * m_ulBytesPerPixel;
  273.         m_lRowStride                = (m_lRowBytes + 3) & ~3;
  275.         // Determine the number of bytes we need
  276.         UINT32 ulNumBytes = m_lRowStride * m_cBitmapInfo.biHeight;
  278.         //  Make sure the provided buffer is big enough
  279.         if (pBuffer->GetSize() >= ulNumBytes)
  280.         {
  281.             // Save the passed in buffer
  282.             HX_RELEASE(m_pImageStore);
  283.             m_pImageStore = pBuffer;
  284.             m_pImageStore->AddRef();
  286.             // Set the image buffer to beginning of storage
  287.             if (m_bRowsInverted)
  288.             {
  289.                 m_pImageBuffer = m_pImageStore->GetBuffer() + (m_cBitmapInfo.biHeight - 1) * m_lRowStride;
  290.                 m_lRowJump     = - m_lRowStride;
  291.             }
  292.             else
  293.             {
  294.                 m_pImageBuffer = m_pImageStore->GetBuffer();
  295.                 m_lRowJump     = m_lRowStride;
  296.             }
  298.             // Set the initialization flag
  299.             m_bInitialized = TRUE;
  300.         }
  301.         else
  302.         {
  303.             retVal = HXR_INVALID_PARAMETER;
  304.         }
  305.     }
  306.     else
  307.     {
  308.         retVal = HXR_INVALID_PARAMETER;
  309.     }
  311.     return retVal;
  312. }
  314. HX_RESULT PXImage::CreateSubImage(PXImage* pImg, INT32 lX, INT32 lY, INT32 lW, INT32 lH,
  315.                                   BOOL bCopy, BOOL bAlloc)
  316. {
  317.     // Check for input error
  318.     if (!pImg || lX < 0 || lY < 0 || lW < 0 || lH < 0)
  319.     {
  320.         HX_ASSERT(FALSE);
  321.         return HXR_FAIL;
  322.     }
  324.     // Adjust for default input
  325.     if (lW == 0)
  326.     {
  327.         lW = pImg->GetWidth();
  328.     }
  329.     if (lH == 0)
  330.     {
  331.         lH = pImg->GetHeight();
  332.     }
  334.     // Check for input error
  335.     if (lX + lW >  pImg->GetWidth())
  336.     {
  337.         lW = pImg->GetWidth() - lX;
  338.     }
  339.     if (lY + lH >  pImg->GetHeight())
  340.     {
  341.         lH = pImg->GetHeight() - lY;
  342.     }
  344.     // Check to see if we're asked NOT to copy but to alloc
  345.     if (!bCopy && bAlloc)
  346.     {
  347.         HX_ASSERT(FALSE);
  348.         return HXR_FAIL;
  349.     }
  351.     // Reset everything (except image store)
  352.     ResetMembers();
  354.     // Are we copying or not?
  355.     if (bCopy)
  356.     {
  357.         // Set member variables
  358.         m_cBitmapInfo.biWidth       = lW;
  359.         m_cBitmapInfo.biHeight      = lH;
  360.         m_cBitmapInfo.biBitCount    = pImg->m_cBitmapInfo.biBitCount;
  361.         m_cBitmapInfo.biCompression = pImg->m_cBitmapInfo.biCompression;
  362.         m_cSubImageRect.left        = 0;
  363.         m_cSubImageRect.top         = 0;
  364.         m_cSubImageRect.right       = lW;
  365.         m_cSubImageRect.bottom      = lH;
  366.         m_lSubImageWidth            = lW;
  367.         m_lSubImageHeight           = lH;
  368.         m_bRowsInverted             = pImg->m_bRowsInverted;
  369.         m_ulBytesPerPixel           = pImg->m_ulBytesPerPixel;
  370.         m_lRowBytes                 = lW * m_ulBytesPerPixel;
  371.         m_lRowStride                = (m_lRowBytes + 3) & ~3;
  372.         m_bHasAlpha                 = pImg->m_bHasAlpha;
  374.         // Determine the number of bytes we need
  375.         UINT32 ulNumBytes = m_lRowStride * m_cBitmapInfo.biHeight;
  377.         // Check to see if we need to alloc memory. We will allocate
  378.         // if the bAlloc parameter tells us to OR if bAlloc is FALSE
  379.         // AND we have don't already have enough to satisfy the request.
  380.         if (bAlloc || (!bAlloc && m_pImageStore->GetSize() < ulNumBytes))
  381.         {
  382.             // Create a new image store
  383.             HX_RELEASE(m_pImageStore);
  384.             m_pImageStore = (IHXBuffer *) new CHXBuffer();
  385.             if (!m_pImageStore)
  386.             {
  387.                 ResetMembers();
  388.                 return HXR_OUTOFMEMORY;
  389.             }
  390.             m_pImageStore->AddRef();
  392.             // Set its size
  393.             HX_RESULT retVal     = m_pImageStore->SetSize(ulNumBytes);
  394.             if (retVal != HXR_OK)
  395.             {
  396.                 Destroy();
  397.                 return retVal;
  398.             }
  399.         }
  401.         // Set the image buffer
  402.         if (m_bRowsInverted)
  403.         {
  404.             m_pImageBuffer = m_pImageStore->GetBuffer() + (m_cBitmapInfo.biHeight - 1) * m_lRowStride;
  405.             m_lRowJump     = - m_lRowStride;
  406.         }
  407.         else
  408.         {
  409.             m_pImageBuffer = m_pImageStore->GetBuffer();
  410.             m_lRowJump     = m_lRowStride;
  411.         }
  413.         // Copy the data
  414.         BYTE* pSrcRow = pImg->m_pImageBuffer + lY * pImg->m_lRowJump + lX * pImg->m_ulBytesPerPixel;
  415.         BYTE* pDstRow = m_pImageBuffer;
  416.         for (INT32 i = m_cBitmapInfo.biHeight; i; i--)
  417.         {
  418.             memcpy(pDstRow, pSrcRow, m_lRowBytes); /* Flawfinder: ignore */
  419.             pSrcRow += pImg->m_lRowJump;
  420.             pDstRow += m_lRowJump;
  421.         }
  422.     }
  423.     else
  424.     {
  425.         // Set member variables
  426.         m_cBitmapInfo          = pImg->m_cBitmapInfo;
  427.         m_cSubImageRect.left   = lX;
  428.         m_cSubImageRect.top    = lY;
  429.         m_cSubImageRect.right  = lX + lW;
  430.         m_cSubImageRect.bottom = lY + lH;
  431.         m_lSubImageWidth       = lW;
  432.         m_lSubImageHeight      = lH;
  433.         m_ulBytesPerPixel      = pImg->m_ulBytesPerPixel;
  434.         m_bRowsInverted        = pImg->m_bRowsInverted;
  435.         m_lRowBytes            = lW * m_ulBytesPerPixel;
  436.         m_bHasAlpha            = pImg->m_bHasAlpha;
  438.         // We ARE NOT copying, so our row stride and jump are the same
  439.         // as the source image
  440.         m_lRowStride = pImg->m_lRowStride;
  441.         m_lRowJump   = pImg->m_lRowJump;
  443.         // Ref the other image store
  444.         HX_RELEASE(m_pImageStore);
  445.         m_pImageStore = pImg->m_pImageStore;
  446.         m_pImageStore->AddRef();
  448.         // Set the image buffer properly (note that we must offset
  449.         // from the other object's m_pImageBuffer member and NOT the
  450.         // image store member - because we may be a subimage of a subimage)
  451.         m_pImageBuffer = pImg->m_pImageBuffer + (lY * m_lRowJump) + (lX * m_ulBytesPerPixel);
  452.     }
  454.     // Set the initialization flag
  455.     m_bInitialized = TRUE;
  457.     return HXR_OK;
  458. }
  460. HX_RESULT PXImage::CreateSubImage(PXImage* pImg, const PXRect& rSubRect,
  461.                                   BOOL bCopy, BOOL bAlloc)
  462. {
  463.     return CreateSubImage(pImg, (INT32) rSubRect.GetX(), (INT32) rSubRect.GetY(),
  464.                           (INT32) rSubRect.GetWidth(), (INT32) rSubRect.GetHeight(),
  465.                           bCopy, bAlloc);
  466. }
  468. HX_RESULT PXImage::CreateSubImage(PXImage* pImg, const HXxRect& rSubRect,
  469.                                   BOOL bCopy, BOOL bAlloc)
  470. {
  471.     return CreateSubImage(pImg, rSubRect.left, rSubRect.top, HXxRECT_WIDTH(rSubRect),
  472.                           HXxRECT_HEIGHT(rSubRect), bCopy, bAlloc);
  473. }
  474. HX_RESULT PXImage::CreateSubImageFromBuffer(PXImage* pImg, INT32 lX, INT32 lY,
  475.                                             INT32 lW, INT32 lH, IHXBuffer* pBuffer)
  476. {
  477.     HX_RESULT retVal = HXR_OK;
  479.     // Check for input error
  480.     if (pImg && lX >= 0 && lY >= 0 && lW >= 0 && lH >= 0)
  481.     {
  482.         // Adjust for default input
  483.         if (lW == 0)
  484.         {
  485.             lW = pImg->GetWidth();
  486.         }
  487.         if (lH == 0)
  488.         {
  489.             lH = pImg->GetHeight();
  490.         }
  492.         // Check for input error
  493.         if (lX + lW >  pImg->GetWidth())
  494.         {
  495.             lW = pImg->GetWidth() - lX;
  496.         }
  497.         if (lY + lH >  pImg->GetHeight())
  498.         {
  499.             lH = pImg->GetHeight() - lY;
  500.         }
  502.         // Reset everything (except image store)
  503.         ResetMembers();
  505.         // Set member variables
  506.         m_cBitmapInfo.biWidth       = lW;
  507.         m_cBitmapInfo.biHeight      = lH;
  508.         m_cBitmapInfo.biBitCount    = pImg->m_cBitmapInfo.biBitCount;
  509.         m_cBitmapInfo.biCompression = pImg->m_cBitmapInfo.biCompression;
  510.         m_cSubImageRect.left        = 0;
  511.         m_cSubImageRect.top         = 0;
  512.         m_cSubImageRect.right       = lW;
  513.         m_cSubImageRect.bottom      = lH;
  514.         m_lSubImageWidth            = lW;
  515.         m_lSubImageHeight           = lH;
  516.         m_bRowsInverted             = pImg->m_bRowsInverted;
  517.         m_ulBytesPerPixel           = pImg->m_ulBytesPerPixel;
  518.         m_lRowBytes                 = lW * m_ulBytesPerPixel;
  519.         m_lRowStride                = (m_lRowBytes + 3) & ~3;
  520.         m_bHasAlpha                 = pImg->m_bHasAlpha;
  522.         // Determine the number of bytes we need
  523.         UINT32 ulNumBytes = m_lRowStride * m_cBitmapInfo.biHeight;
  525.         // Make sure that the buffer we were provided is big enough
  526.         if (pBuffer->GetSize() >= ulNumBytes)
  527.         {
  528.             // Save the buffer
  529.             HX_RELEASE(m_pImageStore);
  530.             m_pImageStore = pBuffer;
  531.             m_pImageStore->AddRef();
  533.             // Set the image buffer
  534.             if (m_bRowsInverted)
  535.             {
  536.                 m_pImageBuffer = m_pImageStore->GetBuffer() + (m_cBitmapInfo.biHeight - 1) * m_lRowStride;
  537.                 m_lRowJump     = - m_lRowStride;
  538.             }
  539.             else
  540.             {
  541.                 m_pImageBuffer = m_pImageStore->GetBuffer();
  542.                 m_lRowJump     = m_lRowStride;
  543.             }
  545.             // Copy the data
  546.             BYTE* pSrcRow = pImg->m_pImageBuffer + lY * pImg->m_lRowJump + lX * pImg->m_ulBytesPerPixel;
  547.             BYTE* pDstRow = m_pImageBuffer;
  548.             for (INT32 i = m_cBitmapInfo.biHeight; i; i--)
  549.             {
  550.                 memcpy(pDstRow, pSrcRow, m_lRowBytes); /* Flawfinder: ignore */
  551.                 pSrcRow += pImg->m_lRowJump;
  552.                 pDstRow += m_lRowJump;
  553.             }
  554.         }
  555.         else
  556.         {
  557.             retVal = HXR_INVALID_PARAMETER;
  558.         }
  559.     }
  560.     else
  561.     {
  562.         retVal = HXR_INVALID_PARAMETER;
  563.     }
  565.     if (SUCCEEDED(retVal))
  566.     {
  567.         // Set the initialization flag
  568.         m_bInitialized = TRUE;
  569.     }
  571.     return retVal;
  572. }
  574. HX_RESULT PXImage::CreateSubImageFromBuffer(PXImage* pImg, const PXRect& rSubRect, IHXBuffer* pBuffer)
  575. {
  576.     return CreateSubImageFromBuffer(pImg, (INT32) rSubRect.GetX(), (INT32) rSubRect.GetY(),
  577.                                     (INT32) rSubRect.GetWidth(), (INT32) rSubRect.GetHeight(), pBuffer);
  578. }
  580. void PXImage::Destroy()
  581. {
  582.     HX_RELEASE(m_pImageStore);
  583.     ResetMembers();
  584. }
  586. HX_RESULT PXImage::Fill(const PXColor& rColor)
  587. {
  588.     UINT32 ulColor = MAKE_RGBA32(rColor.GetRed(),
  589.                                  rColor.GetGreen(),
  590.                                  rColor.GetBlue(),
  591.                                  rColor.GetAlpha());
  592.     return Fill32(ulColor);
  593. }
  595. HX_RESULT PXImage::Fill32(UINT32 ulColor)
  596. {
  597.     HX_RESULT retVal = HXR_OK;
  599.     if (m_bInitialized)
  600.     {
  601.         if (m_cBitmapInfo.biBitCount == 32 &&
  602.             CompressionSupported())
  603.         {
  604.             UINT32* pRow    = (UINT32*) m_pImageBuffer;
  605.             INT32   lJump   = m_lRowJump >> 2;
  606.             for (UINT32 ulY = (UINT32) m_lSubImageHeight; ulY; ulY--)
  607.             {
  608.                 UINT32* pPixel = pRow;
  609.                 for (UINT32 ulX = (UINT32) m_lSubImageWidth; ulX; ulX--)
  610.                 {
  611.                     *pPixel++ = ulColor;
  612.                 }
  613.                 pRow += lJump;
  614.             }
  615.         }
  616.         else
  617.         {
  618.             retVal = HXR_FAIL;
  619.         }
  620.     }
  621.     else
  622.     {
  623.         retVal = HXR_NOT_INITIALIZED;
  624.     }
  626.     return retVal;
  627. }
  629. HX_RESULT PXImage::Blend(PXImage* pImg1, PXImage* pImg2, BYTE* pLUT1, BYTE* pLUT2)
  630. {
  631.     if (!pImg1 || !pImg2 || !pLUT1 || !pLUT2 || !m_bInitialized)
  632.     {
  633.         HX_ASSERT(FALSE);
  634.         return HXR_FAIL;
  635.     }
  637.     FILTER_OUT_UNSUPPORTED_FORMATS;
  639.     if (!Compatible(pImg1) || !Compatible(pImg2) || !SameSize(pImg1) || !SameSize(pImg2))
  640.     {
  641.         HX_ASSERT(FALSE);
  642.         return HXR_FAIL;
  643.     }
  645.     UINT32* pSrcRow1  = (UINT32*) pImg1->m_pImageBuffer;
  646.     UINT32* pSrcRow2  = (UINT32*) pImg2->m_pImageBuffer;
  647.     UINT32* pDstRow   = (UINT32*) m_pImageBuffer;
  648.     INT32   lSrc1Jump = pImg1->m_lRowJump >> 2;
  649.     INT32   lSrc2Jump = pImg2->m_lRowJump >> 2;
  650.     INT32   lDstJump  = m_lRowJump       >> 2;
  651.     for (INT32 lY = m_lSubImageHeight; lY; lY--)
  652.     {
  653.         UINT32* pSrc1 = pSrcRow1;
  654.         UINT32* pSrc2 = pSrcRow2;
  655.         UINT32* pDst  = pDstRow;
  656.         if (pImg2->m_bHasAlpha)
  657.         {
  658.             for (INT32 lX = m_lSubImageWidth; lX; lX--)
  659.             {
  660.                 UINT32 ulR = pLUT1[GETRED32(*pSrc1)]   + pLUT2[GETRED32(*pSrc2)];
  661.                 UINT32 ulG = pLUT1[GETGREEN32(*pSrc1)] + pLUT2[GETGREEN32(*pSrc2)];
  662.                 UINT32 ulB = pLUT1[GETBLUE32(*pSrc1)]  + pLUT2[GETBLUE32(*pSrc2)];
  663.                 UINT32 ulA = GETALPHA32(*pSrc2);
  664.                 ulA        = (ulA < 128 ? ulA : ulA + 1); // scale to 256
  665.                 *pDst      = MAKE_RGB32(ALPHABLEND(GETRED32(*pDst),   ulR, ulA),
  666.                                         ALPHABLEND(GETGREEN32(*pDst), ulG, ulA),
  667.                                         ALPHABLEND(GETBLUE32(*pDst),  ulB, ulA));
  668.                 pSrc1++;
  669.                 pSrc2++;
  670.                 pDst++;
  671.             }
  672.         }
  673.         else
  674.         {
  675.             for (INT32 lX = m_lSubImageWidth; lX; lX--)
  676.             {
  677.                 *pDst = MAKE_RGB32(pLUT1[GETRED32(*pSrc1)]   + pLUT2[GETRED32(*pSrc2)],
  678.                                    pLUT1[GETGREEN32(*pSrc1)] + pLUT2[GETGREEN32(*pSrc2)],
  679.                                    pLUT1[GETBLUE32(*pSrc1)]  + pLUT2[GETBLUE32(*pSrc2)]);
  680.                 pSrc1++;
  681.                 pSrc2++;
  682.                 pDst++;
  683.             }
  684.         }
  685.         pSrcRow1 += lSrc1Jump;
  686.         pSrcRow2 += lSrc2Jump;
  687.         pDstRow  += lDstJump;
  688.     }
  690.     return HXR_OK;
  691. }
  693. HX_RESULT PXImage::RecursiveBlend(PXImage* pImg1, BYTE* pLUT1, BYTE* pSelfLUT)
  694. {
  695.     if (!pImg1 || !pLUT1 || !pSelfLUT || !m_bInitialized)
  696.     {
  697.         HX_ASSERT(FALSE);
  698.         return HXR_FAIL;
  699.     }
  701.     FILTER_OUT_UNSUPPORTED_FORMATS;
  703.     if (!Compatible(pImg1) || !SameSize(pImg1))
  704.     {
  705.         HX_ASSERT(FALSE);
  706.         return HXR_FAIL;
  707.     }
  709.     UINT32* pSrcRow1 = (UINT32*) pImg1->m_pImageBuffer;
  710.     UINT32* pDstRow  = (UINT32*) m_pImageBuffer;
  711.     INT32   lSrc1Jump = pImg1->m_lRowJump >> 2;
  712.     INT32   lDstJump  = m_lRowJump       >> 2;
  713.     for (INT32 lY = m_lSubImageHeight; lY; lY--)
  714.     {
  715.         UINT32* pSrc1 = pSrcRow1;
  716.         UINT32* pDst  = pDstRow;
  717.         for (INT32 lX = m_lSubImageWidth; lX; lX--)
  718.         {
  719.             *pDst = MAKE_RGB32(pLUT1[GETRED32(*pSrc1)]   + pSelfLUT[GETRED32(*pDst)],
  720.                                pLUT1[GETGREEN32(*pSrc1)] + pSelfLUT[GETGREEN32(*pDst)],
  721.                                pLUT1[GETBLUE32(*pSrc1)]  + pSelfLUT[GETBLUE32(*pDst)]);
  722.             pSrc1++;
  723.             pDst++;
  724.         }
  725.         pSrcRow1 += lSrc1Jump;
  726.         pDstRow  += lDstJump;
  727.     }
  729.     return HXR_OK;
  730. }
  732. HX_RESULT PXImage::BlendToColor(PXImage* pImg1, const PXColor& rColor, BYTE* pLUT1, BYTE* pLUT2)
  733. {
  734.     if (!pImg1 || !pLUT1 || !pLUT2 || !m_bInitialized)
  735.     {
  736.         HX_ASSERT(FALSE);
  737.         return HXR_FAIL;
  738.     }
  740.     FILTER_OUT_UNSUPPORTED_FORMATS;
  742.     if (!Compatible(pImg1) || !SameSize(pImg1))
  743.     {
  744.         HX_ASSERT(FALSE);
  745.         return HXR_FAIL;
  746.     }
  748.     BYTE ucFadedR = pLUT2[rColor.GetRed()];
  749.     BYTE ucFadedG = pLUT2[rColor.GetGreen()];
  750.     BYTE ucFadedB = pLUT2[rColor.GetBlue()];
  752.     UINT32* pSrcRow1 = (UINT32*) pImg1->m_pImageBuffer;
  753.     UINT32* pDstRow  = (UINT32*) m_pImageBuffer;
  754.     INT32   lSrc1Jump = pImg1->m_lRowJump >> 2;
  755.     INT32   lDstJump  = m_lRowJump       >> 2;
  756.     for (INT32 lY = m_lSubImageHeight; lY; lY--)
  757.     {
  758.         UINT32* pSrc1 = pSrcRow1;
  759.         UINT32* pDst  = pDstRow;
  760.         for (INT32 lX = m_lSubImageWidth; lX; lX--)
  761.         {
  762.             *pDst = MAKE_RGB32(pLUT1[GETRED32(*pSrc1)]   + ucFadedR,
  763.                                pLUT1[GETGREEN32(*pSrc1)] + ucFadedG,
  764.                                pLUT1[GETBLUE32(*pSrc1)]  + ucFadedB);
  765.             pSrc1++;
  766.             pDst++;
  767.         }
  768.         pSrcRow1 += lSrc1Jump;
  769.         pDstRow  += lDstJump;
  770.     }
  772.     return HXR_OK;
  773. }
  775. HX_RESULT PXImage::RecursiveBlendToColor(const PXColor& rColor, BYTE* pLUT1, BYTE* pLUT2)
  776. {
  777.     if (!pLUT1 || !pLUT2 || !m_bInitialized)
  778.     {
  779.         HX_ASSERT(FALSE);
  780.         return HXR_FAIL;
  781.     }
  783.     FILTER_OUT_UNSUPPORTED_FORMATS;
  785.     BYTE ucFadedR = pLUT2[rColor.GetRed()];
  786.     BYTE ucFadedG = pLUT2[rColor.GetGreen()];
  787.     BYTE ucFadedB = pLUT2[rColor.GetBlue()];
  789.     UINT32* pDstRow  = (UINT32*) m_pImageBuffer;
  790.     INT32   lDstJump = m_lRowJump       >> 2;
  791.     for (INT32 lY = m_lSubImageHeight; lY; lY--)
  792.     {
  793.         UINT32* pDst  = pDstRow;
  794.         for (INT32 lX = m_lSubImageWidth; lX; lX--)
  795.         {
  796.             *pDst = MAKE_RGB32(pLUT1[GETRED32(*pDst)]   + ucFadedR,
  797.                                pLUT1[GETGREEN32(*pDst)] + ucFadedG,
  798.                                pLUT1[GETBLUE32(*pDst)]  + ucFadedB);
  799.             pDst++;
  800.         }
  801.         pDstRow  += lDstJump;
  802.     }
  804.     return HXR_OK;
  805. }
  807. HX_RESULT PXImage::ChangeSizeFromNN(PXImage* pImg)
  808. {
  809.     if (!pImg || !m_bInitialized || !pImg->m_bInitialized)
  810.     {
  811.         HX_ASSERT(FALSE);
  812.         return HXR_FAIL;
  813.     }
  815.     FILTER_OUT_UNSUPPORTED_FORMATS;
  817.     if (!Compatible(pImg))
  818.     {
  819.         HX_ASSERT(FALSE);
  820.         return HXR_FAIL;
  821.     }
  823.     return ChangeSize32NN((UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
  824.                           pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2,
  825.                           (UINT32*) m_pImageBuffer,       m_lSubImageWidth,
  826.                           m_lSubImageHeight,              m_lRowJump >> 2);
  827. }
  829. HX_RESULT PXImage::ChangeSizeFromNNTransparent32(PXImage* pImg)
  830. {
  831.     HX_RESULT retVal = HXR_OK;
  833.     if (pImg)
  834.     {
  835.         if (m_bInitialized && pImg->m_bInitialized)
  836.         {
  837.             if (m_cBitmapInfo.biBitCount          == 32      &&
  838.                 pImg->m_cBitmapInfo.biBitCount    == 32      &&
  839.                 CompressionSupported()                       &&
  840.                 pImg->CompressionSupported())
  841.             {
  842.                 if (Compatible(pImg))
  843.                 {
  844.                     retVal = ChangeSize32NNTransparent((UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
  845.                                                        pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2,
  846.                                                        (UINT32*) m_pImageBuffer,       m_lSubImageWidth,
  847.                                                        m_lSubImageHeight,              m_lRowJump >> 2);
  848.                 }
  849.                 else
  850.                 {
  851.                     retVal = HXR_FAIL;
  852.                 }
  853.             }
  854.             else
  855.             {
  856.                 retVal = HXR_FAIL;
  857.             }
  858.         }
  859.         else
  860.         {
  861.             retVal = HXR_NOT_INITIALIZED;
  862.         }
  863.     }
  864.     else
  865.     {
  866.         retVal = HXR_INVALID_PARAMETER;
  867.     }
  869.     return retVal;
  870. }
  872. HX_RESULT PXImage::ChangeSizeIntoNN(PXImage* pImg)
  873. {
  874.     if (!pImg || !m_bInitialized || !pImg->m_bInitialized)
  875.     {
  876.         HX_ASSERT(FALSE);
  877.         return HXR_FAIL;
  878.     }
  880.     FILTER_OUT_UNSUPPORTED_FORMATS;
  882.     if (!Compatible(pImg))
  883.     {
  884.         HX_ASSERT(FALSE);
  885.         return HXR_FAIL;
  886.     }
  888.     return ChangeSize32NN((UINT32*) m_pImageBuffer,       m_lSubImageWidth,
  889.                           m_lSubImageHeight,              m_lRowJump >> 2,
  890.                           (UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
  891.                           pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2);
  892. }
  894. HX_RESULT PXImage::ChangeSizeIntoNNTransparent32(PXImage* pImg)
  895. {
  896.     HX_RESULT retVal = HXR_OK;
  898.     if (pImg)
  899.     {
  900.         if (m_bInitialized && pImg->m_bInitialized)
  901.         {
  902.             if (m_cBitmapInfo.biBitCount          == 32      &&
  903.                 pImg->m_cBitmapInfo.biBitCount    == 32      &&
  904.                 CompressionSupported()                       &&
  905.                 pImg->CompressionSupported())
  906.             {
  907.                 if (Compatible(pImg))
  908.                 {
  909.                     retVal = ChangeSize32NNTransparent((UINT32*) m_pImageBuffer,       m_lSubImageWidth,
  910.                                                        m_lSubImageHeight,              m_lRowJump >> 2,
  911.                                                        (UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
  912.                                                        pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2);
  913.                 }
  914.                 else
  915.                 {
  916.                     retVal = HXR_FAIL;
  917.                 }
  918.             }
  919.             else
  920.             {
  921.                 retVal = HXR_FAIL;
  922.             }
  923.         }
  924.         else
  925.         {
  926.             retVal = HXR_NOT_INITIALIZED;
  927.         }
  928.     }
  929.     else
  930.     {
  931.         retVal = HXR_INVALID_PARAMETER;
  932.     }
  934.     return retVal;
  935. }
  937. HX_RESULT PXImage::CopyFrom(PXImage* pImg)
  938. {
  939.     if (!pImg || !m_bInitialized)
  940.     {
  941.         HX_ASSERT(FALSE);
  942.         return HXR_FAIL;
  943.     }
  945.     FILTER_OUT_UNSUPPORTED_FORMATS;
  947.     if (!Compatible(pImg) || !SameSize(pImg))
  948.     {
  949.         HX_ASSERT(FALSE);
  950.         return HXR_FAIL;
  951.     }
  953.     Copy32((UINT32*) pImg->m_pImageBuffer, (UINT32*) m_pImageBuffer,
  954.             pImg->m_lRowJump >> 2,         m_lRowJump >> 2,
  955.             pImg->m_bHasAlpha);
  957.     return HXR_OK;
  958. }
  960. HX_RESULT PXImage::CopyFromTransparent32(PXImage* pImg)
  961. {
  962.     HX_RESULT retVal = HXR_OK;
  964.     if (pImg)
  965.     {
  966.         if (m_bInitialized && pImg->m_bInitialized)
  967.         {
  968.             if (m_cBitmapInfo.biBitCount          == 32      &&
  969.                 pImg->m_cBitmapInfo.biBitCount    == 32      &&
  970.                 CompressionSupported()                       &&
  971.                 pImg->CompressionSupported())
  972.             {
  973.                 if (Compatible(pImg) && SameSize(pImg))
  974.                 {
  975.                     CopyTransparent32((UINT32*) pImg->m_pImageBuffer,
  976.                                       (UINT32*) m_pImageBuffer,
  977.                                       pImg->m_lRowJump >> 2,
  978.                                       m_lRowJump >> 2);
  979.                 }
  980.                 else
  981.                 {
  982.                     retVal = HXR_INVALID_PARAMETER;
  983.                 }
  984.             }
  985.             else
  986.             {
  987.                 retVal = HXR_FAIL;
  988.             }
  989.         }
  990.         else
  991.         {
  992.             retVal = HXR_NOT_INITIALIZED;
  993.         }
  994.     }
  995.     else
  996.     {
  997.         retVal = HXR_INVALID_PARAMETER;
  998.     }
  1000.     return retVal;
  1001. }
  1003. HX_RESULT PXImage::CopyFromAlpha32(PXImage* pImg, BYTE* pLUT)
  1004. {
  1005.     HX_RESULT retVal = HXR_FAIL;
  1007.     if (pImg)
  1008.     {
  1009.         if (m_bInitialized && pImg->m_bInitialized)
  1010.         {
  1011.             if (m_cBitmapInfo.biBitCount          == 32      &&
  1012.                 pImg->m_cBitmapInfo.biBitCount    == 32      &&
  1013.                 CompressionSupported()                       &&
  1014.                 pImg->CompressionSupported())
  1015.             {
  1016.                 if (Compatible(pImg) && SameSize(pImg))
  1017.                 {
  1018.                     CopyAlpha32((UINT32*) pImg->m_pImageBuffer,
  1019.                                 (UINT32*) m_pImageBuffer,
  1020.                                 pImg->m_lRowJump >> 2,
  1021.                                 m_lRowJump >> 2,
  1022.                                 pLUT);
  1023.                     retVal = HXR_OK;
  1024.                 }
  1025.             }
  1026.         }
  1027.     }
  1029.     return retVal;
  1030. }
  1032. HX_RESULT PXImage::CopyTo(PXImage* pImg)
  1033. {
  1034.     if (!pImg || !m_bInitialized)
  1035.     {
  1036.         HX_ASSERT(FALSE);
  1037.         return HXR_FAIL;
  1038.     }
  1040.     FILTER_OUT_UNSUPPORTED_FORMATS;
  1042.     if (!Compatible(pImg) || !SameSize(pImg))
  1043.     {
  1044.         HX_ASSERT(FALSE);
  1045.         return HXR_FAIL;
  1046.     }
  1048.     Copy32((UINT32*) m_pImageBuffer, (UINT32*) pImg->m_pImageBuffer,
  1049.            m_lRowJump >> 2,          pImg->m_lRowJump >> 2,
  1050.            m_bHasAlpha);
  1052.     return HXR_OK;
  1053. }
  1055. HX_RESULT PXImage::CopyToTransparent32(PXImage* pImg)
  1056. {
  1057.     HX_RESULT retVal = HXR_OK;
  1059.     if (pImg)
  1060.     {
  1061.         if (m_bInitialized && pImg->m_bInitialized)
  1062.         {
  1063.             if (m_cBitmapInfo.biBitCount          == 32      &&
  1064.                 pImg->m_cBitmapInfo.biBitCount    == 32      &&
  1065.                 CompressionSupported()                       &&
  1066.                 pImg->CompressionSupported())
  1067.             {
  1068.                 if (Compatible(pImg) && SameSize(pImg))
  1069.                 {
  1070.                     CopyTransparent32((UINT32*) m_pImageBuffer,
  1071.                                       (UINT32*) pImg->m_pImageBuffer,
  1072.                                       m_lRowJump >> 2,
  1073.                                       pImg->m_lRowJump >> 2);
  1074.                 }
  1075.                 else
  1076.                 {
  1077.                     retVal = HXR_INVALID_PARAMETER;
  1078.                 }
  1079.             }
  1080.             else
  1081.             {
  1082.                 retVal = HXR_FAIL;
  1083.             }
  1084.         }
  1085.         else
  1086.         {
  1087.             retVal = HXR_NOT_INITIALIZED;
  1088.         }
  1089.     }
  1090.     else
  1091.     {
  1092.         retVal = HXR_INVALID_PARAMETER;
  1093.     }
  1095.     return retVal;
  1096. }
  1098. HX_RESULT PXImage::CopyToAlpha32(PXImage* pImg, BYTE* pLUT)
  1099. {
  1100.     HX_RESULT retVal = HXR_FAIL;
  1102.     if (pImg)
  1103.     {
  1104.         if (m_bInitialized && pImg->m_bInitialized)
  1105.         {
  1106.             if (m_cBitmapInfo.biBitCount          == 32      &&
  1107.                 pImg->m_cBitmapInfo.biBitCount    == 32      &&
  1108.                 CompressionSupported()                       &&
  1109.                 pImg->CompressionSupported())
  1110.             {
  1111.                 if (Compatible(pImg) && SameSize(pImg))
  1112.                 {
  1113.                     CopyAlpha32((UINT32*) m_pImageBuffer,
  1114.                                 (UINT32*) pImg->m_pImageBuffer,
  1115.                                 m_lRowJump >> 2,
  1116.                                 pImg->m_lRowJump >> 2,
  1117.                                 pLUT);
  1118.                     retVal = HXR_OK;
  1119.                 }
  1120.             }
  1121.         }
  1122.     }
  1124.     return retVal;
  1125. }
  1127. HX_RESULT PXImage::FlipFrom(PXImage* pImg, BOOL bVerticalAxis)
  1128. {
  1129.     HX_RESULT retVal = HXR_OK;
  1131.     if (pImg)
  1132.     {
  1133.         if (m_bInitialized)
  1134.         {
  1135.             if (Compatible(pImg) && SameSize(pImg))
  1136.             {
  1137.                 if (bVerticalAxis)
  1138.                 {
  1139.                     VertAxisFlip32((UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
  1140.                                    pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2,
  1141.                                    (UINT32*) m_pImageBuffer,       m_lSubImageWidth,
  1142.                                    m_lSubImageHeight,              m_lRowJump >> 2);
  1143.                 }
  1144.                 else
  1145.                 {
  1146.                     HorzAxisFlip32((UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
  1147.                                    pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2,
  1148.                                    (UINT32*) m_pImageBuffer,       m_lSubImageWidth,
  1149.                                    m_lSubImageHeight,              m_lRowJump >> 2);
  1150.                 }
  1151.             }
  1152.             else
  1153.             {
  1154.                 retVal = HXR_FAIL;
  1155.             }
  1156.         }
  1157.         else
  1158.         {
  1159.             retVal = HXR_NOT_INITIALIZED;
  1160.         }
  1161.     }
  1162.     else
  1163.     {
  1164.         retVal = HXR_INVALID_PARAMETER;
  1165.     }
  1167.     return retVal;
  1168. }
  1170. HX_RESULT PXImage::FlipTo(PXImage* pImg, BOOL bVerticalAxis)
  1171. {
  1172.     HX_RESULT retVal = HXR_OK;
  1174.     if (pImg)
  1175.     {
  1176.         if (m_bInitialized)
  1177.         {
  1178.             if (Compatible(pImg) && SameSize(pImg))
  1179.             {
  1180.                 if (bVerticalAxis)
  1181.                 {
  1182.                     VertAxisFlip32((UINT32*) m_pImageBuffer,       m_lSubImageWidth,
  1183.                                    m_lSubImageHeight,              m_lRowJump >> 2,
  1184.                                    (UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
  1185.                                    pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2);
  1186.                 }
  1187.                 else
  1188.                 {
  1189.                     HorzAxisFlip32((UINT32*) m_pImageBuffer,       m_lSubImageWidth,
  1190.                                    m_lSubImageHeight,              m_lRowJump >> 2,
  1191.                                    (UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
  1192.                                    pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2);
  1193.                 }
  1194.             }
  1195.             else
  1196.             {
  1197.                 retVal = HXR_FAIL;
  1198.             }
  1199.         }
  1200.         else
  1201.         {
  1202.             retVal = HXR_NOT_INITIALIZED;
  1203.         }
  1204.     }
  1205.     else
  1206.     {
  1207.         retVal = HXR_INVALID_PARAMETER;
  1208.     }
  1210.     return retVal;
  1211. }
  1213. HX_RESULT PXImage::Wipe(PXImage* pStartImg, PXImage* pEndImg, UINT32 ulType,
  1214.                         UINT32 ulDirection, UINT32 ulTime, UINT32 ulDuration)
  1215. {
  1216.     HX_RESULT retVal = HXR_OK;
  1218.     if (pStartImg                                       &&
  1219.         pEndImg                                         &&
  1220.         (ulType == PXEffect::kWipeTypeNormal         ||
  1221.          ulType == PXEffect::kWipeTypePush)             &&
  1222.         (ulDirection == PXEffect::kWipeDirectionUp   ||
  1223.          ulDirection == PXEffect::kWipeDirectionDown ||
  1224.          ulDirection == PXEffect::kWipeDirectionLeft ||
  1225.          ulDirection == PXEffect::kWipeDirectionRight)  &&
  1226.         ulTime     > 0                                  &&
  1227.         ulTime     < ulDuration                         &&
  1228.         ulDuration > 0)
  1229.     {
  1230.         if (m_bInitialized)
  1231.         {
  1232.             if (Compatible(pStartImg) && SameSize(pStartImg) &&
  1233.                 Compatible(pEndImg)   && SameSize(pEndImg))
  1234.             {
  1235.                 // Set up src and dst rectangles for both
  1236.                 // the start and end images
  1237.                 PXRect cStartSrc;
  1238.                 PXRect cStartDst;
  1239.                 PXRect cEndSrc;
  1240.                 PXRect cEndDst;
  1241.                 UINT32 ulW = pStartImg->GetWidth();
  1242.                 UINT32 ulH = pStartImg->GetHeight();
  1243.                 if (ulType == PXEffect::kWipeTypeNormal)
  1244.                 {
  1245.                     if (ulDirection == PXEffect::kWipeDirectionUp)
  1246.                     {
  1247.                         UINT32 ulY = (ulDuration - ulTime) * ulH / ulDuration;
  1248.                         cStartSrc.Set(0, 0, ulW, ulY);
  1249.                         cEndSrc.Set(0, ulY, ulW, ulH - ulY);
  1250.                     }
  1251.                     else if (ulDirection == PXEffect::kWipeDirectionDown)
  1252.                     {
  1253.                         UINT32 ulY = ulTime * ulH / ulDuration;
  1254.                         cStartSrc.Set(0, ulY, ulW, ulH - ulY);
  1255.                         cEndSrc.Set(0, 0, ulW, ulY);
  1256.                     }
  1257.                     else if (ulDirection == PXEffect::kWipeDirectionLeft)
  1258.                     {
  1259.                         UINT32 ulX = (ulDuration - ulTime) * ulW / ulDuration;
  1260.                         cStartSrc.Set(0, 0, ulX, ulH);
  1261.                         cEndSrc.Set(ulX, 0, ulW - ulX, ulH);
  1262.                     }
  1263.                     else if (ulDirection == PXEffect::kWipeDirectionRight)
  1264.                     {
  1265.                         UINT32 ulX = ulTime * ulW / ulDuration;
  1266.                         cStartSrc.Set(ulX, 0, ulW - ulX, ulH);
  1267.                         cEndSrc.Set(0, 0, ulX, ulH);
  1268.                     }
  1269.                     cStartDst = cStartSrc;
  1270.                     cEndDst   = cEndSrc;
  1271.                 }
  1272.                 else
  1273.                 {
  1274.                     if (ulDirection == PXEffect::kWipeDirectionUp)
  1275.                     {
  1276.                         UINT32 ulY = (ulDuration - ulTime) * ulH / ulDuration;
  1277.                         cStartSrc.Set(0, ulH - ulY, ulW, ulY);
  1278.                         cStartDst.Set(0, 0, ulW, ulY);
  1279.                         cEndSrc.Set(0, 0, ulW, ulH - ulY);
  1280.                         cEndDst.Set(0, ulY, ulW, ulH - ulY);
  1281.                     }
  1282.                     else if (ulDirection == PXEffect::kWipeDirectionDown)
  1283.                     {
  1284.                         UINT32 ulY = ulTime * ulH / ulDuration;
  1285.                         cStartSrc.Set(0, 0, ulW, ulH - ulY);
  1286.                         cStartDst.Set(0, ulY, ulW, ulH - ulY);
  1287.                         cEndSrc.Set(0, ulH - ulY, ulW, ulY);
  1288.                         cEndDst.Set(0, 0, ulW, ulY);
  1289.                     }
  1290.                     else if (ulDirection == PXEffect::kWipeDirectionLeft)
  1291.                     {
  1292.                         UINT32 ulX = (ulDuration - ulTime) * ulW / ulDuration;
  1293.                         cStartSrc.Set(ulW - ulX, 0, ulX, ulH);
  1294.                         cStartDst.Set(0, 0, ulX, ulH);
  1295.                         cEndSrc.Set(0, 0, ulW - ulX, ulH);
  1296.                         cEndDst.Set(ulX, 0, ulW - ulX, ulH);
  1297.                     }
  1298.                     else if (ulDirection == PXEffect::kWipeDirectionRight)
  1299.                     {
  1300.                         UINT32 ulX = ulTime * ulW / ulDuration;
  1301.                         cStartSrc.Set(0, 0, ulW - ulX, ulH);
  1302.                         cStartDst.Set(ulX, 0, ulW - ulX, ulH);
  1303.                         cEndSrc.Set(ulW - ulX, 0,ulX, ulH);
  1304.                         cEndDst.Set(0, 0, ulX, ulH);
  1305.                     }
  1306.                 }
  1308.                 // Copy from the start image
  1309.                 if (cStartSrc.GetWidth() > 0 && cStartSrc.GetHeight() > 0)
  1310.                 {
  1311.                     // Create the start src image
  1312.                     PXImage cStartSrcImg;
  1313.                     retVal = cStartSrcImg.CreateSubImage(pStartImg, cStartSrc);
  1314.                     if (SUCCEEDED(retVal))
  1315.                     {
  1316.                         // Create the start dst image
  1317.                         PXImage cStartDstImg;
  1318.                         retVal = cStartDstImg.CreateSubImage(this, cStartDst);
  1319.                         if (SUCCEEDED(retVal))
  1320.                         {
  1321.                             // Now copy the start image
  1322.                             retVal = cStartDstImg.CopyFrom(&cStartSrcImg);
  1323.                         }
  1324.                     }
  1325.                 }
  1327.                 if (SUCCEEDED(retVal))
  1328.                 {
  1329.                     // Copy from the dst image
  1330.                     if (cEndSrc.GetWidth() > 0 && cEndSrc.GetHeight() > 0)
  1331.                     {
  1332.                         // Create the end src image
  1333.                         PXImage cEndSrcImg;
  1334.                         retVal = cEndSrcImg.CreateSubImage(pEndImg, cEndSrc);
  1335.                         if (SUCCEEDED(retVal))
  1336.                         {
  1337.                             // Create the end dst image
  1338.                             PXImage cEndDstImg;
  1339.                             retVal = cEndDstImg.CreateSubImage(this, cEndDst);
  1340.                             if (SUCCEEDED(retVal))
  1341.                             {
  1342.                                 // Now copy the end image
  1343.                                 retVal = cEndDstImg.CopyFrom(&cEndSrcImg);
  1344.                             }
  1345.                         }
  1346.                     }
  1347.                 }
  1348.             }
  1349.             else
  1350.             {
  1351.                 retVal = HXR_FAIL;
  1352.             }
  1353.         }
  1354.         else
  1355.         {
  1356.             retVal = HXR_NOT_INITIALIZED;
  1357.         }
  1358.     }
  1359.     else
  1360.     {
  1361.         retVal = HXR_INVALID_PARAMETER;
  1362.     }
  1364.     return retVal;
  1365. }
  1367. HX_RESULT PXImage::RecursiveWipe(PXImage* pEndImage, UINT32 ulType, UINT32 ulDirection, UINT32 ulLastTime,
  1368.                                  UINT32 ulTime, UINT32 ulDuration, PXRect& rDamageRect)
  1369. {
  1370.     HX_RESULT retVal = HXR_OK;
  1372.     if (pEndImage                                       &&
  1373.         (ulType == PXEffect::kWipeTypeNormal         ||
  1374.          ulType == PXEffect::kWipeTypePush)             &&
  1375.         (ulDirection == PXEffect::kWipeDirectionUp   ||
  1376.          ulDirection == PXEffect::kWipeDirectionDown ||
  1377.          ulDirection == PXEffect::kWipeDirectionLeft ||
  1378.          ulDirection == PXEffect::kWipeDirectionRight)  &&
  1379.         ulTime     > 0                                  &&
  1380.         ulTime     < ulDuration                         &&
  1381.         ulTime     > ulLastTime                         &&
  1382.         ulDuration > 0)
  1383.     {
  1384.         if (m_bInitialized)
  1385.         {
  1386.             if (Compatible(pEndImage) && SameSize(pEndImage))
  1387.             {
  1388.                 // Set up src and dst rectangles for both
  1389.                 // the start and end images
  1390.                 UINT32 ulW = pEndImage->GetWidth();
  1391.                 UINT32 ulH = pEndImage->GetHeight();
  1392.                 if (ulType == PXEffect::kWipeTypeNormal)
  1393.                 {
  1394.                     PXRect cRect;
  1395.                     if (ulDirection == PXEffect::kWipeDirectionUp)
  1396.                     {
  1397.                         UINT32 ulY     = (ulDuration - ulTime) * ulH / ulDuration;
  1398.                         UINT32 ulLastY = (ulDuration - ulLastTime) * ulH / ulDuration;
  1399.                         cRect.Set(0, ulY, ulW, ulLastY - ulY);
  1400.                     }
  1401.                     else if (ulDirection == PXEffect::kWipeDirectionDown)
  1402.                     {
  1403.                         UINT32 ulY     = ulTime * ulH / ulDuration;
  1404.                         UINT32 ulLastY = ulLastTime * ulH / ulDuration;
  1405.                         cRect.Set(0, ulLastY, ulW, ulY - ulLastY);
  1406.                     }
  1407.                     else if (ulDirection == PXEffect::kWipeDirectionLeft)
  1408.                     {
  1409.                         UINT32 ulX     = (ulDuration - ulTime) * ulW / ulDuration;
  1410.                         UINT32 ulLastX = (ulDuration - ulLastTime) * ulW / ulDuration;
  1411.                         cRect.Set(ulX, 0, ulLastX - ulX, ulH);
  1412.                     }
  1413.                     else if (ulDirection == PXEffect::kWipeDirectionRight)
  1414.                     {
  1415.                         UINT32 ulX     = ulTime * ulW / ulDuration;
  1416.                         UINT32 ulLastX = ulLastTime * ulW / ulDuration;
  1417.                         cRect.Set(ulLastX, 0, ulX - ulLastX, ulH);
  1418.                     }
  1420.                     // Make sure that we have something to copy
  1421.                     if (cRect.GetWidth() > 0 && cRect.GetHeight() > 0)
  1422.                     {
  1423.                         // Set up the source image
  1424.                         PXImage cEndSrcImg;
  1425.                         retVal = cEndSrcImg.CreateSubImage(pEndImage, cRect);
  1426.                         if (SUCCEEDED(retVal))
  1427.                         {
  1428.                             // Set up the destination image
  1429.                             PXImage cEndDstImg;
  1430.                             retVal = cEndDstImg.CreateSubImage(this, cRect);
  1431.                             if (SUCCEEDED(retVal))
  1432.                             {
  1433.                                 retVal = cEndDstImg.CopyFrom(&cEndSrcImg);
  1434.                                 if (SUCCEEDED(retVal))
  1435.                                 {
  1436.                                     rDamageRect = cRect;
  1437.                                 }
  1438.                             }
  1439.                         }
  1440.                     }
  1441.                 }
  1442.                 else
  1443.                 {
  1444.                     PXRect cIntraSrcRect;
  1445.                     PXRect cIntraDstRect;
  1446.                     PXRect cEndSrcRect;
  1447.                     PXRect cEndDstRect;
  1448.                     if (ulDirection == PXEffect::kWipeDirectionUp)
  1449.                     {
  1450.                         UINT32 ulY     = (ulDuration - ulTime) * ulH / ulDuration;
  1451.                         UINT32 ulLastY = (ulDuration - ulLastTime) * ulH / ulDuration;
  1452.                         UINT32 ulYDiff = ulLastY - ulY;
  1453.                         cIntraSrcRect.Set(0, ulYDiff, ulW, ulH - ulYDiff);
  1454.                         cIntraDstRect.Set(0, 0, ulW, ulH - ulYDiff);
  1455.                         cEndSrcRect.Set(0, ulH - ulLastY, ulW, ulYDiff);
  1456.                         cEndDstRect.Set(0, ulH - ulYDiff, ulW, ulYDiff);
  1457.                     }
  1458.                     else if (ulDirection == PXEffect::kWipeDirectionDown)
  1459.                     {
  1460.                         UINT32 ulY     = ulTime * ulH / ulDuration;
  1461.                         UINT32 ulLastY = ulLastTime * ulH / ulDuration;
  1462.                         UINT32 ulYDiff = ulY - ulLastY;
  1463.                         cIntraSrcRect.Set(0, 0, ulW, ulH - ulYDiff);
  1464.                         cIntraDstRect.Set(0, ulYDiff, ulW, ulH - ulYDiff);
  1465.                         cEndSrcRect.Set(0, ulH - ulY, ulW, ulYDiff);
  1466.                         cEndDstRect.Set(0, 0, ulW, ulYDiff);
  1467.                     }
  1468.                     else if (ulDirection == PXEffect::kWipeDirectionLeft)
  1469.                     {
  1470.                         UINT32 ulX     = (ulDuration - ulTime) * ulW / ulDuration;
  1471.                         UINT32 ulLastX = (ulDuration - ulLastTime) * ulW / ulDuration;
  1472.                         UINT32 ulXDiff = ulLastX - ulX;
  1473.                         cIntraSrcRect.Set(ulXDiff, 0, ulW - ulXDiff, ulH);
  1474.                         cIntraDstRect.Set(0, 0, ulW - ulXDiff, ulH);
  1475.                         cEndSrcRect.Set(ulW - ulLastX, 0, ulXDiff, ulH);
  1476.                         cEndDstRect.Set(ulW - ulXDiff, 0, ulXDiff, ulH);
  1477.                     }
  1478.                     else if (ulDirection == PXEffect::kWipeDirectionRight)
  1479.                     {
  1480.                         UINT32 ulX     = ulTime * ulW / ulDuration;
  1481.                         UINT32 ulLastX = ulLastTime * ulW / ulDuration;
  1482.                         UINT32 ulXDiff = ulX - ulLastX;
  1483.                         cIntraSrcRect.Set(0, 0, ulW - ulXDiff, ulH);
  1484.                         cIntraDstRect.Set(ulXDiff, 0, ulW - ulXDiff, ulH);
  1485.                         cEndSrcRect.Set(ulW - ulX, 0, ulXDiff, ulH);
  1486.                         cEndDstRect.Set(0, 0, ulXDiff, ulH);
  1487.                     }
  1489.                     // Make sure we have something to copy
  1490.                     if (cIntraSrcRect.GetWidth() == 0 || cIntraSrcRect.GetHeight() == 0)
  1491.                     {
  1492.                         // This is all end image, so just do a copy
  1493.                         retVal = CopyFrom(pEndImage);
  1494.                     }
  1495.                     else if (cEndSrcRect.GetWidth() > 0 && cEndSrcRect.GetHeight() > 0)
  1496.                     {
  1497.                         // First we do an intra copy to copy the part of 
  1498.                         // the image which is already there.
  1499.                         retVal = IntraCopy(cIntraSrcRect, cIntraDstRect);
  1500.                         if (SUCCEEDED(retVal))
  1501.                         {
  1502.                             PXImage cEndSrcImg;
  1503.                             retVal = cEndSrcImg.CreateSubImage(pEndImage, cEndSrcRect);
  1504.                             if (SUCCEEDED(retVal))
  1505.                             {
  1506.                                 PXImage cEndDstImg;
  1507.                                 retVal = cEndDstImg.CreateSubImage(this, cEndDstRect);
  1508.                                 if (SUCCEEDED(retVal))
  1509.                                 {
  1510.                                     retVal = cEndDstImg.CopyFrom(&cEndSrcImg);
  1511.                                     if (SUCCEEDED(retVal))
  1512.                                     {
  1513.                                         rDamageRect.Set(0, 0, ulW, ulH);
  1514.                                     }
  1515.                                 }
  1516.                             }
  1517.                         }
  1518.                     }
  1519.                 }
  1520.             }
  1521.             else
  1522.             {
  1523.                 retVal = HXR_FAIL;
  1524.             }
  1525.         }
  1526.         else
  1527.         {
  1528.             retVal = HXR_NOT_INITIALIZED;
  1529.         }
  1530.     }
  1531.     else
  1532.     {
  1533.         retVal = HXR_INVALID_PARAMETER;
  1534.     }
  1536.     return retVal;
  1537. }
  1539. HX_RESULT PXImage::IntraCopy(const PXRect& rSrcRect, const PXRect& rDstRect)
  1540. {
  1541.     HX_RESULT retVal = HXR_OK;
  1543.     if (rSrcRect.GetWidth()  == rDstRect.GetWidth()        &&
  1544.         rSrcRect.GetHeight() == rDstRect.GetHeight()       &&
  1545.         rSrcRect.GetWidth()  <= (UINT32) m_lSubImageWidth  &&
  1546.         rSrcRect.GetHeight() <= (UINT32) m_lSubImageHeight &&
  1547.         rSrcRect.GetX() + rSrcRect.GetWidth()  <= (UINT32) m_lSubImageWidth  &&
  1548.         rSrcRect.GetY() + rSrcRect.GetHeight() <= (UINT32) m_lSubImageHeight &&
  1549.         rDstRect.GetX() + rDstRect.GetWidth()  <= (UINT32) m_lSubImageWidth  &&
  1550.         rDstRect.GetY() + rDstRect.GetHeight() <= (UINT32) m_lSubImageHeight)
  1551.     {
  1552.         // Make sure this is not a null copy
  1553.         if (rSrcRect.GetX() != rDstRect.GetX() ||
  1554.             rSrcRect.GetY() != rDstRect.GetY())
  1555.         {
  1556.             BOOL bUpCopy = (rDstRect.GetY() <= rSrcRect.GetY() ? TRUE : FALSE);
  1557. //            if (m_bRowsInverted)
  1558. //            {
  1559. //                // If we are row-inverted, then we reverse whatever, operation
  1560. //                // we were going to do.
  1561. //                bUpCopy = (bUpCopy ? FALSE : TRUE);
  1562. //            }
  1563.             if (rDstRect.GetX() <= rSrcRect.GetX())
  1564.             {
  1565.                 // This is a left-ward copy
  1566.                 if (bUpCopy)
  1567.                 {
  1568.                     // This is an up-left copy, so we do L->R, T->B
  1569.                     UINT32* pSrcRow = (UINT32*) GetPixel(rSrcRect.GetX(), rSrcRect.GetY());
  1570.                     UINT32* pDstRow = (UINT32*) GetPixel(rDstRect.GetX(), rDstRect.GetY());
  1571.                     INT32   lJump   = m_lRowJump >> 2;
  1572.                     for (UINT32 ulY = rSrcRect.GetHeight(); ulY; ulY--)
  1573.                     {
  1574.                         UINT32* pSrcPixel = pSrcRow;
  1575.                         UINT32* pDstPixel = pDstRow;
  1576.                         for (UINT32 ulX = rSrcRect.GetWidth(); ulX; ulX--)
  1577.                         {
  1578.                             *pDstPixel++ = *pSrcPixel++;
  1579.                         }
  1580.                         pSrcRow += lJump;
  1581.                         pDstRow += lJump;
  1582.                     }
  1583.                 }
  1584.                 else
  1585.                 {
  1586.                     // This is a down-left copy, so we do L->R, B->T
  1587.                     UINT32* pSrcRow = (UINT32*) GetPixel(rSrcRect.GetX(), rSrcRect.GetY() + rSrcRect.GetHeight() - 1);
  1588.                     UINT32* pDstRow = (UINT32*) GetPixel(rDstRect.GetX(), rDstRect.GetY() + rDstRect.GetHeight() - 1);
  1589.                     INT32   lJump   = m_lRowJump >> 2;
  1590.                     for (UINT32 ulY = rSrcRect.GetHeight(); ulY; ulY--)
  1591.                     {
  1592.                         UINT32* pSrcPixel = pSrcRow;
  1593.                         UINT32* pDstPixel = pDstRow;
  1594.                         for (UINT32 ulX = rSrcRect.GetWidth(); ulX; ulX--)
  1595.                         {
  1596.                             *pDstPixel++ = *pSrcPixel++;
  1597.                         }
  1598.                         pSrcRow -= lJump;
  1599.                         pDstRow -= lJump;
  1600.                     }
  1601.                 }
  1602.             }
  1603.             else
  1604.             {
  1605.                 // This is a right-ward copy
  1606.                 if (bUpCopy)
  1607.                 {
  1608.                     // This is an up-right copy, so we do R->L, T->B
  1609.                     UINT32* pSrcRow = (UINT32*) GetPixel(rSrcRect.GetX() + rSrcRect.GetWidth() - 1, rSrcRect.GetY());
  1610.                     UINT32* pDstRow = (UINT32*) GetPixel(rDstRect.GetX() + rDstRect.GetWidth() - 1, rDstRect.GetY());
  1611.                     INT32   lJump   = m_lRowJump >> 2;
  1612.                     for (UINT32 ulY = rSrcRect.GetHeight(); ulY; ulY--)
  1613.                     {
  1614.                         UINT32* pSrcPixel = pSrcRow;
  1615.                         UINT32* pDstPixel = pDstRow;
  1616.                         for (UINT32 ulX = rSrcRect.GetWidth(); ulX; ulX--)
  1617.                         {
  1618.                             *pDstPixel-- = *pSrcPixel--;
  1619.                         }
  1620.                         pSrcRow += lJump;
  1621.                         pDstRow += lJump;
  1622.                     }
  1623.                 }
  1624.                 else
  1625.                 {
  1626.                     // This is a down-right copy, so we do R->L, B->T
  1627.                     UINT32* pSrcRow = (UINT32*) GetPixel(rSrcRect.GetX() + rSrcRect.GetWidth()  - 1,
  1628.                                                          rSrcRect.GetY() + rSrcRect.GetHeight() - 1);
  1629.                     UINT32* pDstRow = (UINT32*) GetPixel(rDstRect.GetX() + rDstRect.GetWidth()  - 1,
  1630.                                                          rDstRect.GetY() + rDstRect.GetHeight() - 1);
  1631.                     INT32   lJump   = m_lRowJump >> 2;
  1632.                     for (UINT32 ulY = rSrcRect.GetHeight(); ulY; ulY--)
  1633.                     {
  1634.                         UINT32* pSrcPixel = pSrcRow;
  1635.                         UINT32* pDstPixel = pDstRow;
  1636.                         for (UINT32 ulX = rSrcRect.GetWidth(); ulX; ulX--)
  1637.                         {
  1638.                             *pDstPixel-- = *pSrcPixel--;
  1639.                         }
  1640.                         pSrcRow -= lJump;
  1641.                         pDstRow -= lJump;
  1642.                     }
  1643.                 }
  1644.             }
  1645.         }
  1646.     }
  1647.     else
  1648.     {
  1649.         retVal = HXR_INVALID_PARAMETER;
  1650.     }
  1652.     return retVal;
  1653. }
  1655. HX_RESULT PXImage::DrawToHXSurface(IHXVideoSurface* pSurface, HXxRect& rDstRect)
  1656. {
  1657.     if (!m_bInitialized || !pSurface)
  1658.     {
  1659.         HX_ASSERT(FALSE);
  1660.         return HXR_FAIL;
  1661.     }
  1663.     // If the image has alpha, then we need to
  1664.     // blt a different colorspace
  1665.     UINT32 ulFormat = m_cBitmapInfo.biCompression;
  1666.     if (m_bHasAlpha)
  1667.     {
  1668.         m_cBitmapInfo.biCompression = HX_ARGB;
  1669.     }
  1670.     // Do the blt
  1671.     pSurface->AddRef();
  1672.     HX_RESULT retVal = pSurface->Blt(m_pImageStore->GetBuffer(), &m_cBitmapInfo, rDstRect, m_cSubImageRect);
  1673.     pSurface->Release();
  1674.     // Restore the old colorspace
  1675.     if (m_bHasAlpha)
  1676.     {
  1677.         m_cBitmapInfo.biCompression = ulFormat;
  1678.     }
  1680.     return retVal;
  1681. }
  1683. HX_RESULT PXImage::DrawToHXSurface(IHXVideoSurface* pSurface, HXxRect& rSrcRect, HXxRect& rDstRect)
  1684. {
  1685.     HX_RESULT retVal = HXR_OK;
  1687.     if (pSurface)
  1688.     {
  1689.         if (m_bInitialized)
  1690.         {
  1691.             // If the image has alpha, then we need to
  1692.             // blt a different colorspace
  1693.             UINT32 ulFormat = m_cBitmapInfo.biCompression;
  1694.             if (m_bHasAlpha)
  1695.             {
  1696.                 m_cBitmapInfo.biCompression = HX_ARGB;
  1697.             }
  1698.             // Do the blt
  1699.             pSurface->AddRef();
  1700.             retVal = pSurface->Blt(m_pImageStore->GetBuffer(), &m_cBitmapInfo, rDstRect, rSrcRect);
  1701.             pSurface->Release();
  1702.             // Restore the old colorspace
  1703.             if (m_bHasAlpha)
  1704.             {
  1705.                 m_cBitmapInfo.biCompression = ulFormat;
  1706.             }
  1707.         }
  1708.         else
  1709.         {
  1710.             retVal = HXR_UNEXPECTED;
  1711.         }
  1712.     }
  1713.     else
  1714.     {
  1715.         retVal = HXR_INVALID_PARAMETER;
  1716.     }
  1718.     return retVal;
  1719. }
  1721. HX_RESULT PXImage::GetPixel(INT32 lX, INT32 lY, BYTE** ppPixel)
  1722. {
  1723.     *ppPixel = GetPixel(lX, lY);
  1724.     return (*ppPixel ? HXR_OK : HXR_FAIL);
  1725. }
  1727. BYTE* PXImage::GetPixel(INT32 lX, INT32 lY)
  1728. {
  1729.     BYTE* pRet = NULL;
  1731.     if (m_bInitialized)
  1732.     {
  1733.         if (lX >= 0 && lX < m_lSubImageWidth &&
  1734.             lY >= 0 && lY < m_lSubImageHeight)
  1735.         {
  1736.             pRet = m_pImageBuffer + lY * m_lRowJump + lX * m_ulBytesPerPixel;
  1737.         }
  1738.     }
  1740.     return pRet;
  1741. }
  1743. HX_RESULT PXImage::GetImageStore(IHXBuffer** ppBuffer)
  1744. {
  1745.     HX_RESULT retVal = HXR_OK;
  1746.     if (ppBuffer && m_bInitialized)
  1747.     {
  1748.         m_pImageStore->AddRef();
  1749.         *ppBuffer = m_pImageStore;
  1750.     }
  1751.     else
  1752.     {
  1753.         retVal = HXR_FAIL;
  1754.     }
  1755.     return retVal;
  1756. }
  1758. void PXImage::ConvertToRGBOrder(INT32 lScanline, BYTE* pLine)
  1759. {
  1760.     if (lScanline >= 0 && lScanline < m_lSubImageHeight)
  1761.     {
  1762.         UINT32* pPixel = (UINT32*) GetPixel(0, lScanline);
  1763.         for (INT32 lX = m_lSubImageWidth; lX; lX--)
  1764.         {
  1765.             UINT32 ulPixel = *pPixel++;
  1766.             *pLine++ = (BYTE) ((ulPixel & 0x00FF0000) >> 16); // R
  1767.             *pLine++ = (BYTE) ((ulPixel & 0x0000FF00) >>  8); // G
  1768.             *pLine++ = (BYTE)  (ulPixel & 0x000000FF);        // B
  1769.         }
  1770.     }
  1771. }
  1773. void PXImage::ConvertFromRGBOrder(INT32 lScanline, BYTE* pLine)
  1774. {
  1775.     if (lScanline >= 0 && lScanline < m_lSubImageHeight)
  1776.     {
  1777.         UINT32* pPixel = (UINT32*) GetPixel(0, lScanline);
  1778.         for (INT32 lX = m_lSubImageWidth; lX; lX--)
  1779.         {
  1780.             UINT32 ulRed   = *pLine++;
  1781.             UINT32 ulGreen = *pLine++;
  1782.             UINT32 ulBlue  = *pLine++;
  1783.             *pPixel++      = (ulRed << 16) | (ulGreen << 8) | ulBlue;
  1784.         }
  1785.     }
  1786. }
  1788. void PXImage::GetSubRect(PXRect& rRect) const
  1789. {
  1790.     rRect.Set(m_cSubImageRect.left,
  1791.               m_cSubImageRect.top,
  1792.               HXxRECT_WIDTH(m_cSubImageRect),
  1793.               HXxRECT_HEIGHT(m_cSubImageRect));
  1794. }
  1796. BOOL PXImage::SameSize(PXImage* pImg) const
  1797. {
  1798.     if (pImg                                         &&
  1799.         m_lSubImageWidth  == pImg->m_lSubImageWidth  &&
  1800.         m_lSubImageHeight == pImg->m_lSubImageHeight)
  1801.     {
  1802.         return TRUE;
  1803.     }
  1804.     else
  1805.     {
  1806.         return FALSE;
  1807.     }
  1808. }
  1810. BOOL PXImage::Compatible(PXImage* pImg) const
  1811. {
  1812.     if (pImg                                                          &&
  1813.         m_cBitmapInfo.biBitCount    == pImg->m_cBitmapInfo.biBitCount &&
  1814.         m_cBitmapInfo.biCompression == pImg->m_cBitmapInfo.biCompression)
  1815.     {
  1816.         return TRUE;
  1817.     }
  1818.     else
  1819.     {
  1820.         return FALSE;
  1821.     }
  1822. }
  1824. void PXImage::Copy32(UINT32* pSrc, UINT32* pDst, INT32 lSrcJump, INT32 lDstJump, BOOL bUseAlpha)
  1825. {
  1826.     for (INT32 lY = m_lSubImageHeight; lY; lY--)
  1827.     {
  1828.         UINT32* pSrcPix = pSrc;
  1829.         UINT32* pDstPix = pDst;
  1830.         if (bUseAlpha)
  1831.         {
  1832.             for (INT32 lX = m_lSubImageWidth; lX; lX--)
  1833.             {
  1834.                 UINT32 ulA = GETALPHA32(*pSrcPix);
  1835.                 ulA        = (ulA < 128 ? ulA : ulA + 1);
  1836.                 *pDstPix   = MAKE_RGB32(ALPHABLEND(GETRED32(*pDstPix),   GETRED32(*pSrcPix),   ulA),
  1837.                                         ALPHABLEND(GETGREEN32(*pDstPix), GETGREEN32(*pSrcPix), ulA),
  1838.                                         ALPHABLEND(GETBLUE32(*pDstPix),  GETBLUE32(*pSrcPix),  ulA));
  1839.                 pSrcPix++;
  1840.                 pDstPix++;
  1841.             }
  1842.         }
  1843.         else
  1844.         {
  1845.             for (INT32 lX = m_lSubImageWidth; lX; lX--)
  1846.             {
  1847.                 *pDstPix++ = *pSrcPix++;
  1848.             }
  1849.         }
  1850.         pSrc += lSrcJump;
  1851.         pDst += lDstJump;
  1852.     }
  1853. }
  1855. void PXImage::CopyTransparent32(UINT32* pSrc, UINT32* pDst, INT32 lSrcJump, INT32 lDstJump)
  1856. {
  1857.     for (INT32 lY = m_lSubImageHeight; lY; lY--)
  1858.     {
  1859.         UINT32* pSrcPix = pSrc;
  1860.         UINT32* pDstPix = pDst;
  1861.         for (INT32 lX = m_lSubImageWidth; lX; lX--)
  1862.         {
  1863.             if (!(*pSrcPix & 0xFF000000))
  1864.             {
  1865.                 *pDstPix = *pSrcPix;
  1866.             }
  1867.             pSrcPix++;
  1868.             pDstPix++;
  1869.         }
  1870.         pSrc += lSrcJump;
  1871.         pDst += lDstJump;
  1872.     }
  1873. }
  1875. void PXImage::CopyAlpha32(UINT32* pSrc, UINT32* pDst, INT32 lSrcJump, INT32 lDstJump, BYTE* pLUT)
  1876. {
  1877.     if (pLUT)
  1878.     {
  1879.         for (INT32 lY = m_lSubImageHeight; lY; lY--)
  1880.         {
  1881.             UINT32* pSrcPix = pSrc;
  1882.             UINT32* pDstPix = pDst;
  1883.             for (INT32 lX = m_lSubImageWidth; lX; lX--)
  1884.             {
  1885.                 UINT32 ulAlpha = GETALPHA32(*pSrcPix);
  1886.                 BYTE*  pAlp    = &pLUT[ulAlpha << 8];
  1887.                 BYTE*  pInv    = &pLUT[(255 - ulAlpha) << 8];
  1888.                 *pDstPix       = MAKE_RGB32(pAlp[GETRED32(*pDstPix)]   + pInv[GETRED32(*pSrcPix)],
  1889.                                             pAlp[GETGREEN32(*pDstPix)] + pInv[GETGREEN32(*pSrcPix)],
  1890.                                             pAlp[GETBLUE32(*pDstPix)]  + pInv[GETBLUE32(*pSrcPix)]);
  1891.                 pSrcPix++;
  1892.                 pDstPix++;
  1893.             }
  1894.             pSrc += lSrcJump;
  1895.             pDst += lDstJump;
  1896.         }
  1897.     }
  1898.     else
  1899.     {
  1900.         for (INT32 lY = m_lSubImageHeight; lY; lY--)
  1901.         {
  1902.             UINT32* pSrcPix = pSrc;
  1903.             UINT32* pDstPix = pDst;
  1904.             for (INT32 lX = m_lSubImageWidth; lX; lX--)
  1905.             {
  1906.                 UINT32 ulAlpha = GETALPHA32(*pSrcPix);
  1907.                 *pDstPix       = MAKE_RGB32(BLENDMULT(GETRED32(*pDstPix),   GETRED32(*pSrcPix),   ulAlpha),
  1908.                                             BLENDMULT(GETGREEN32(*pDstPix), GETGREEN32(*pSrcPix), ulAlpha),
  1909.                                             BLENDMULT(GETBLUE32(*pDstPix),  GETBLUE32(*pSrcPix),  ulAlpha));
  1910.                 pSrcPix++;
  1911.                 pDstPix++;
  1912.             }
  1913.             pSrc += lSrcJump;
  1914.             pDst += lDstJump;
  1915.         }
  1916.     }
  1917. }
  1919. HX_RESULT PXImage::ChangeSize32NN(UINT32* pSrc, INT32 lSrcW, INT32 lSrcH, INT32 lSrcJump,
  1920.                                   UINT32* pDst, INT32 lDstW, INT32 lDstH, INT32 lDstJump)
  1921. {
  1922.     // Allocate the divide LUT
  1923.     INT32* pSrcX = new INT32 [lDstW];
  1924.     if (!pSrcX)
  1925.     {
  1926.         return HXR_OUTOFMEMORY;
  1927.     }
  1929.     // Build the divide LUT
  1930.     INT32 lDstX;
  1931.     INT32 lDstWDiv2 = lDstW >> 1;
  1932.     for (lDstX = 0; lDstX < lDstW; lDstX++)
  1933.     {
  1934.         INT32 lSrcX = (lDstX * lSrcW + lDstWDiv2) / lDstW;
  1935.         if (lSrcX >= lSrcW)
  1936.         {
  1937.             lSrcX = lSrcW - 1;
  1938.         }
  1939.         pSrcX[lDstX] = lSrcX;
  1940.     }
  1942.     // Now run through the output image, doing nearest neighbor resampling
  1943.     INT32   lSrcY     = 0;
  1944.     INT32   lDstY     = 0;
  1945.     INT32   lLastSrcY = -1;
  1946.     UINT32* pDstRow   = pDst;
  1947.     INT32   lDstHDiv2 = lDstH >> 1;
  1948.     for (lDstY = 0; lDstY < lDstH; lDstY++)
  1949.     {
  1950.         lSrcY = (lDstY * lSrcH + lDstHDiv2) / lDstH;
  1951.         if (lSrcY >= lSrcH)
  1952.         {
  1953.             lSrcY = lSrcH - 1;
  1954.         }
  1955.         UINT32* pSrcRow = pSrc + lSrcY * lSrcJump;
  1956.         if (lSrcY == lLastSrcY)
  1957.         {
  1958.             // We're getting this resampled row from the same source row,
  1959.             // so just copy the last row.
  1960.             UINT32* pDstLastRow = pDstRow - lDstJump;
  1961.             for (lDstX = 0; lDstX < lDstW; lDstX++)
  1962.             {
  1963.                 pDstRow[lDstX] = pDstLastRow[lDstX];
  1964.             }
  1965.         }
  1966.         else
  1967.         {
  1968.             // New row, we must do the work
  1969.             for (lDstX = 0; lDstX < lDstW; lDstX++)
  1970.             {
  1971.                 pDstRow[lDstX] = pSrcRow[pSrcX[lDstX]];
  1972.             }
  1973.         }
  1974.         lLastSrcY = lSrcY;
  1975.         pDstRow  += lDstJump;
  1976.     }
  1978.     HX_VECTOR_DELETE(pSrcX);
  1980.     return HXR_OK;
  1981. }
  1983. HX_RESULT PXImage::ChangeSize32NNTransparent(UINT32* pSrc, INT32 lSrcW, INT32 lSrcH, INT32 lSrcJump,
  1984.                                              UINT32* pDst, INT32 lDstW, INT32 lDstH, INT32 lDstJump)
  1985. {
  1986.     // Allocate the divide LUT
  1987.     INT32* pSrcX = new INT32 [lDstW];
  1988.     if (!pSrcX)
  1989.     {
  1990.         return HXR_OUTOFMEMORY;
  1991.     }
  1993.     // Build the divide LUT
  1994.     INT32 lDstX;
  1995.     INT32 lDstWDiv2 = lDstW >> 1;
  1996.     for (lDstX = 0; lDstX < lDstW; lDstX++)
  1997.     {
  1998.         INT32 lSrcX = (lDstX * lSrcW + lDstWDiv2) / lDstW;
  1999.         if (lSrcX >= lSrcW)
  2000.         {
  2001.             lSrcX = lSrcW - 1;
  2002.         }
  2003.         pSrcX[lDstX] = lSrcX;
  2004.     }
  2006.     // Now run through the output image, doing nearest neighbor resampling
  2007.     INT32   lSrcY     = 0;
  2008.     INT32   lDstY     = 0;
  2009.     INT32   lLastSrcY = -1;
  2010.     UINT32* pDstRow   = pDst;
  2011.     INT32   lDstHDiv2 = lDstH >> 1;
  2012.     for (lDstY = 0; lDstY < lDstH; lDstY++)
  2013.     {
  2014.         lSrcY = (lDstY * lSrcH + lDstHDiv2) / lDstH;
  2015.         if (lSrcY >= lSrcH)
  2016.         {
  2017.             lSrcY = lSrcH - 1;
  2018.         }
  2019.         UINT32* pSrcRow = pSrc + lSrcY * lSrcJump;
  2020.         if (lSrcY == lLastSrcY)
  2021.         {
  2022.             // We're getting this resampled row from the same source row,
  2023.             // so just copy the last row.
  2024.             UINT32* pDstLastRow = pDstRow - lDstJump;
  2025.             for (lDstX = 0; lDstX < lDstW; lDstX++)
  2026.             {
  2027.                 pDstRow[lDstX] = pDstLastRow[lDstX];
  2028.             }
  2029.         }
  2030.         else
  2031.         {
  2032.             // New row, we must do the work
  2033.             for (lDstX = 0; lDstX < lDstW; lDstX++)
  2034.             {
  2035.                 UINT32 ulPixel = pSrcRow[pSrcX[lDstX]];
  2036.                 if (!(ulPixel & 0xFF000000))
  2037.                 {
  2038.                     pDstRow[lDstX] = ulPixel;
  2039.                 }
  2040.             }
  2041.         }
  2042.         lLastSrcY = lSrcY;
  2043.         pDstRow  += lDstJump;
  2044.     }
  2046.     HX_VECTOR_DELETE(pSrcX);
  2048.     return HXR_OK;
  2049. }
  2051. void PXImage::HorzAxisFlip32(UINT32* pSrc, INT32 lSrcW, INT32 lSrcH, INT32 lSrcJump,
  2052.                              UINT32* pDst, INT32 lDstW, INT32 lDstH, INT32 lDstJump)
  2053. {
  2054.     UINT32* pSrcRow = pSrc + (lSrcH - 1) * lSrcJump;
  2055.     UINT32* pDstRow = pDst;
  2056.     for (INT32 lY = 0; lY < lSrcH; lY++)
  2057.     {
  2058.         UINT32* pSrcPixel = pSrcRow;
  2059.         UINT32* pDstPixel = pDstRow;
  2060.         for (INT32 lX = lSrcW; lX; lX--)
  2061.         {
  2062.             *pDstPixel++ = *pSrcPixel++;
  2063.         }
  2064.         pSrcRow -= lSrcJump;
  2065.         pDstRow += lDstJump;
  2066.     }
  2067. }
  2069. void PXImage::VertAxisFlip32(UINT32* pSrc, INT32 lSrcW, INT32 lSrcH, INT32 lSrcJump,
  2070.                              UINT32* pDst, INT32 lDstW, INT32 lDstH, INT32 lDstJump)
  2071. {
  2072.     UINT32* pSrcRow = pSrc + lSrcW - 1;
  2073.     UINT32* pDstRow = pDst;
  2074.     for (INT32 lY = 0; lY < lSrcH; lY++)
  2075.     {
  2076.         UINT32 *pSrcPixel = pSrcRow;
  2077.         UINT32 *pDstPixel = pDstRow;
  2078.         for (INT32 lX = lSrcW; lX; lX--)
  2079.         {
  2080.             *pDstPixel++ = *pSrcPixel--;
  2081.         }
  2082.         pSrcRow += lSrcJump;
  2083.         pDstRow += lDstJump;
  2084.     }
  2085. }
  2087. void PXImage::ResetMembers()
  2088. {
  2089.     m_cBitmapInfo.biSize          = 40;
  2090.     m_cBitmapInfo.biWidth         = 0;
  2091.     m_cBitmapInfo.biHeight        = 0;
  2092.     m_cBitmapInfo.biPlanes        = 1;
  2093.     m_cBitmapInfo.biBitCount      = 0;
  2094.     m_cBitmapInfo.biCompression   = HX_RGB;
  2095.     m_cBitmapInfo.biSizeImage     = 0;
  2096.     m_cBitmapInfo.biXPelsPerMeter = 0;
  2097.     m_cBitmapInfo.biYPelsPerMeter = 0;
  2098.     m_cBitmapInfo.biClrUsed       = 0;
  2099.     m_cBitmapInfo.biClrImportant  = 0;
  2100.     m_cBitmapInfo.rcolor          = 0;
  2101.     m_cBitmapInfo.gcolor          = 0;
  2102.     m_cBitmapInfo.bcolor          = 0;
  2103.     m_cSubImageRect.left          = 0;
  2104.     m_cSubImageRect.top           = 0;
  2105.     m_cSubImageRect.right         = 0;
  2106.     m_cSubImageRect.bottom        = 0;
  2107.     m_lSubImageWidth              = 0;
  2108.     m_lSubImageHeight             = 0;
  2109.     m_ulBytesPerPixel             = 0;
  2110.     m_lRowBytes                   = 0;
  2111.     m_lRowStride                  = 0;
  2112.     m_lRowJump                    = 0;
  2113.     m_bRowsInverted               = FALSE;
  2114.     m_pImageBuffer                = NULL;
  2115.     m_bInitialized                = FALSE;
  2116.     m_bHasAlpha                   = FALSE;
  2117. }
  2119. void PXImage::Write(const char* pszFileName, UINT32 ulWriteFormat)
  2120. {
  2121.     if (m_bInitialized && pszFileName)
  2122.     {
  2123.         switch (ulWriteFormat)
  2124.         {
  2125.             case kWriteFormatBinaryRaw:
  2126.                 {
  2127.                     FILE* fp = fopen(pszFileName, "wb");
  2128.                     if (fp)
  2129.                     {
  2130.                         UINT32* pRow      = (UINT32*) m_pImageBuffer;
  2131.                         INT32   lJump     = m_lRowJump >> 2;
  2132.                         INT32   lNumBytes = m_lSubImageWidth << 2;
  2133.                         for (INT32 lY = m_lSubImageHeight; lY; lY--)
  2134.                         {
  2135.                             UINT32* pPixel = pRow;
  2136.                             for (INT32 lX = m_lSubImageWidth; lX; lX--)
  2137.                             {
  2138.                                 BYTE ucTmp = 0;
  2139.                                 ucTmp = (BYTE) GETRED32(*pPixel);
  2140.                                 fwrite(&ucTmp, 1, 1, fp);
  2141.                                 ucTmp = (BYTE) GETGREEN32(*pPixel);
  2142.                                 fwrite(&ucTmp, 1, 1, fp);
  2143.                                 ucTmp = (BYTE) GETBLUE32(*pPixel);
  2144.                                 fwrite(&ucTmp, 1, 1, fp);
  2145.                                 pPixel++;
  2146.                             }
  2147.                             pRow += lJump;
  2148.                         }
  2149.                     }
  2150.                     fclose(fp);
  2151.                 }
  2152.                 break;
  2153.             case kWriteFormatAscii:
  2154.                 {
  2155.                     FILE* fp = fopen(pszFileName, "w");
  2156.                     if (fp)
  2157.                     {
  2158.                         fprintf(fp, "Width=%ld, Height=%ldnFormat is RGBA RGBA ...n",
  2159.                                 m_lSubImageWidth, m_lSubImageHeight);
  2160.                         UINT32* pRow  = (UINT32*) m_pImageBuffer;
  2161.                         INT32   lJump = m_lRowJump >> 2;
  2162.                         for (INT32 lY = m_lSubImageHeight; lY; lY--)
  2163.                         {
  2164.                             UINT32* pPixel = pRow;
  2165.                             for (INT32 lX = m_lSubImageWidth; lX; lX--)
  2166.                             {
  2167.                                 fprintf(fp, "%02X%02X%02X%02X ",
  2168.                                         GETRED32(*pPixel),
  2169.                                         GETGREEN32(*pPixel),
  2170.                                         GETBLUE32(*pPixel),
  2171.                                         GETALPHA32(*pPixel));
  2172.                                 pPixel++;
  2173.                             }
  2174.                             fprintf(fp, "n");
  2175.                             pRow += lJump;
  2176.                         }
  2177.                     }
  2178.                     fclose(fp);
  2179.                 }
  2180.                 break;
  2181.         }
  2182.     }
  2183. }
  2185. HX_RESULT PXImage::GetIterator(PXImageIterator** ppIterator, UINT32 ulType)
  2186. {
  2187.     HX_RESULT        retVal = HXR_OK;
  2188.     PXImageIterator* pIter  = NULL;
  2190.     switch (ulType)
  2191.     {
  2192.         case kIterLRTB:
  2193.             pIter = (PXImageIterator*) new PXImageIteratorLRTB(this);
  2194.             break;
  2195.         case kIterLRBT:
  2196.             pIter = (PXImageIterator*) new PXImageIteratorLRBT(this);
  2197.             break;
  2198.         case kIterRLTB:
  2199.             pIter = (PXImageIterator*) new PXImageIteratorRLTB(this);
  2200.             break;
  2201.         case kIterRLBT:
  2202.             pIter = (PXImageIterator*) new PXImageIteratorRLBT(this);
  2203.             break;
  2204.         case kIterTBLR:
  2205.             pIter = (PXImageIterator*) new PXImageIteratorTBLR(this);
  2206.             break;
  2207.         case kIterTBRL:
  2208.             pIter = (PXImageIterator*) new PXImageIteratorTBRL(this);
  2209.             break;
  2210.         case kIterBTLR:
  2211.             pIter = (PXImageIterator*) new PXImageIteratorBTLR(this);
  2212.             break;
  2213.         case kIterBTRL:
  2214.             pIter = (PXImageIterator*) new PXImageIteratorBTRL(this);
  2215.             break;
  2216.     }
  2218.     if (pIter)
  2219.     {
  2220.         *ppIterator = pIter;
  2221.     }
  2222.     else
  2223.     {
  2224.         *ppIterator = NULL;
  2225.         retVal      = HXR_OUTOFMEMORY;
  2226.     }
  2228.     return retVal;
  2229. }
  2231. void PXImage::SelfDetermineHasAlpha()
  2232. {
  2233.     if (m_bInitialized)
  2234.     {
  2235.         if (m_cBitmapInfo.biBitCount == 32 &&
  2236.             CompressionSupported())
  2237.         {
  2238.             // Pixels are stored as 0xAARRGGBB. If the image doesn't
  2239.             // use alpha, then all the AA bytes will be 0. If any
  2240.             // alpha bytes are non-zero, then the image uses alpha.
  2241.             BOOL    bHasAlpha = FALSE;
  2242.             UINT32* pRow      = (UINT32*) m_pImageBuffer;
  2243.             INT32   lJump     = m_lRowJump >> 2;
  2244.             for (UINT32 ulY = (UINT32) m_lSubImageHeight; ulY && !bHasAlpha; ulY--)
  2245.             {
  2246.                 UINT32* pPixel = pRow;
  2247.                 for (UINT32 ulX = (UINT32) m_lSubImageWidth; ulX && !bHasAlpha; ulX--)
  2248.                 {
  2249.                     if (GETALPHA32(*pPixel++))
  2250.                     {
  2251.                         bHasAlpha = TRUE;
  2252.                     }
  2253.                 }
  2254.                 pRow += lJump;
  2255.             }
  2256.             // Set the member
  2257.             m_bHasAlpha = bHasAlpha;
  2258.         }
  2259.     }
  2260. }
  2262. void PXImage::PreMultiplyAlphaChannel(UINT32 ulColor)
  2263. {
  2264.     if (m_bInitialized && m_bHasAlpha)
  2265.     {
  2266.         UINT32  ulR   = GETRED32(ulColor);
  2267.         UINT32  ulG   = GETGREEN32(ulColor);
  2268.         UINT32  ulB   = GETBLUE32(ulColor);
  2269.         UINT32* pRow  = (UINT32*) m_pImageBuffer;
  2270.         INT32   lJump = m_lRowJump >> 2;
  2271.         for (INT32 lY = m_lSubImageHeight; lY; lY--)
  2272.         {
  2273.             UINT32* pPix = pRow;
  2274.             for (INT32 lX = m_lSubImageWidth; lX; lX--)
  2275.             {
  2276.                 UINT32 ulA = GETALPHA32(*pPix);
  2277.                 ulA        = (ulA < 128 ? ulA : ulA + 1);
  2278.                 *pPix   = MAKE_RGB32(ALPHABLEND(ulR, GETRED32(*pPix),   ulA),
  2279.                                      ALPHABLEND(ulG, GETGREEN32(*pPix), ulA),
  2280.                                      ALPHABLEND(ulB, GETBLUE32(*pPix),  ulA));
  2281.                 pPix++;
  2282.             }
  2283.             pRow += lJump;
  2284.         }
  2285.         // Clear the HasAlpha flag, since we just removed the alpha channel
  2286.         m_bHasAlpha = FALSE;
  2287.     }
  2288. }
  2290. BOOL PXImage::CompressionSupported()
  2291. {
  2292.     BOOL bRet = FALSE;
  2294.     if (m_cBitmapInfo.biCompression == HX_RGB)
  2295.     {
  2296.         bRet = TRUE;
  2297.     }
  2299.     return bRet;
  2300. }