Category

Development Platform
Home > SourceCode/Document > Communication-Mobile > Symbian > View Code
pxtransp.cpp
Package: 142_61_thumb_advanced.rar　[view]
Upload User: dangjiwu
Upload Date: 2013-07-19
Package Size: 42019k
Code Size: 5k
Category:

Symbian

Development Platform:

Visual C++

pxtransp.cpp：Code Content
  1. // include
  2. #include "hxtypes.h"
  3. #include "hxwintyp.h"
  4. #include "hxcom.h"
  5. #include "ihxpckts.h"
  6. // pnmisc
  7. #include "hxparse.h"
  8. // pxcomlib
  9. #include "pxtransp.h"
  11. HX_RESULT ParseTransparencyParameters(IHXValues* pValues,
  12.                                       REF(UINT32) rulBgOpacity,
  13.                                       REF(BOOL)   rbBgOpacitySpecified,
  14.                                       REF(UINT32) rulMediaOpacity,
  15.                                       REF(BOOL)   rbMediaOpacitySpecified,
  16.                                       REF(UINT32) rulChromaKey,
  17.                                       REF(BOOL)   rbChromaKeySpecified,
  18.                                       REF(UINT32) rulChromaKeyTolerance,
  19.                                       REF(UINT32) rulChromaKeyOpacity,
  20.                                       REF(BOOL)   rbAlphaChannelNeeded)
  21. {
  22.     HX_RESULT retVal = HXR_OK;
  24.     if (pValues)
  25.     {
  26.         // Get the background opacity
  27.         IHXBuffer* pStr = NULL;
  28.         HX_RESULT   rv   = pValues->GetPropertyCString("backgroundOpacity", pStr);
  29.         if (SUCCEEDED(rv))
  30.         {
  31.             UINT32 ulTmp = 0;
  32.             retVal = HXParseOpacity((const char*) pStr->GetBuffer(), ulTmp);
  33.             if (SUCCEEDED(retVal))
  34.             {
  35.                 rulBgOpacity         = ulTmp;
  36.                 rbBgOpacitySpecified = TRUE;
  37.                 if (rulBgOpacity < 255)
  38.                 {
  39.                     rbAlphaChannelNeeded = TRUE;
  40.                 }
  41.             }
  42.         }
  43.         if (SUCCEEDED(retVal))
  44.         {
  45.             // Get the media opacity
  46.             HX_RELEASE(pStr);
  47.             rv = pValues->GetPropertyCString("mediaOpacity", pStr);
  48.             if (SUCCEEDED(rv))
  49.             {
  50.                 UINT32 ulTmp = 0;
  51.                 retVal = HXParseOpacity((const char*) pStr->GetBuffer(), ulTmp);
  52.                 if (SUCCEEDED(retVal))
  53.                 {
  54.                     rulMediaOpacity         = ulTmp;
  55.                     rbMediaOpacitySpecified = TRUE;
  56.                     if (rulMediaOpacity < 255)
  57.                     {
  58.                         rbAlphaChannelNeeded = TRUE;
  59.                     }
  60.                 }
  61.             }
  62.         }
  63.         if (SUCCEEDED(retVal))
  64.         {
  65.             // Get the media chromakey
  66.             HX_RELEASE(pStr);
  67.             rv = pValues->GetPropertyCString("chromaKey", pStr);
  68.             if (SUCCEEDED(rv))
  69.             {
  70.                 UINT32 ulTmp = 0;
  71.                 retVal = HXParseColorUINT32((const char*) pStr->GetBuffer(), ulTmp);
  72.                 if (SUCCEEDED(retVal))
  73.                 {
  74.                     rulChromaKey         = ulTmp;
  75.                     rbChromaKeySpecified = TRUE;
  76.                     rbAlphaChannelNeeded = TRUE;
  77.                 }
  78.             }
  79.         }
  80.         if (SUCCEEDED(retVal))
  81.         {
  82.             // Get the media chromakey tolerance
  83.             HX_RELEASE(pStr);
  84.             rv = pValues->GetPropertyCString("chromaKeyTolerance", pStr);
  85.             if (SUCCEEDED(rv))
  86.             {
  87.                 UINT32 ulTmp = 0;
  88.                 retVal = HXParseColorUINT32((const char*) pStr->GetBuffer(), ulTmp);
  89.                 if (SUCCEEDED(retVal))
  90.                 {
  91.                     rulChromaKeyTolerance = ulTmp;
  92.                 }
  93.             }
  94.         }
  95.         if (SUCCEEDED(retVal))
  96.         {
  97.             // Get the chroma key opacity
  98.             HX_RELEASE(pStr);
  99.             rv = pValues->GetPropertyCString("chromaKeyOpacity", pStr);
  100.             if (SUCCEEDED(rv))
  101.             {
  102.                 UINT32 ulTmp = 0;
  103.                 retVal = HXParseOpacity((const char*) pStr->GetBuffer(), ulTmp);
  104.                 if (SUCCEEDED(rv))
  105.                 {
  106.                     rulChromaKeyOpacity = ulTmp;
  107.                 }
  108.             }
  109.         }
  110.         HX_RELEASE(pStr);
  111.     }
  112.     else
  113.     {
  114.         retVal = HXR_FAIL;
  115.     }
  117.     return retVal;
  118. }
  120. BOOL DoesChromaKeyChannelMatch(UINT32 ulColor,
  121.                                UINT32 ulChromaKey,
  122.                                UINT32 ulChromaKeyTol)
  123. {
  124.     BOOL bRet = FALSE;
  126.     INT32 lDiff = ((INT32) ulColor) - ((INT32) ulChromaKey);
  127.     if (lDiff < 0)
  128.     {
  129.         lDiff = -lDiff;
  130.     }
  131.     if (lDiff <= (INT32) ulChromaKeyTol)
  132.     {
  133.         bRet = TRUE;
  134.     }
  136.     return bRet;
  137. }
  139. BOOL DoesChromaKeyMatch(UINT32 ulColor,
  140.                         UINT32 ulChromaKey,
  141.                         UINT32 ulChromaKeyTol)
  142. {
  143.     BOOL bRet = FALSE;
  145.     if (DoesChromaKeyChannelMatch(ARGB32_RED(ulColor),
  146.                                   ARGB32_RED(ulChromaKey),
  147.                                   ARGB32_RED(ulChromaKeyTol)) &&
  148.         DoesChromaKeyChannelMatch(ARGB32_GREEN(ulColor),
  149.                                   ARGB32_GREEN(ulChromaKey),
  150.                                   ARGB32_GREEN(ulChromaKeyTol)) &&
  151.         DoesChromaKeyChannelMatch(ARGB32_BLUE(ulColor),
  152.                                   ARGB32_BLUE(ulChromaKey),
  153.                                   ARGB32_BLUE(ulChromaKeyTol)))
  154.     {
  155.         bRet = TRUE;
  156.     }
  158.     return bRet;
  159. }