pximage.cpp
来自「symbian 下的helix player源代码」· C++ 代码 · 共 1,933 行 · 第 1/5 页
CPP
1,933 行
(UINT32*) m_pImageBuffer, m_lSubImageWidth,
m_lSubImageHeight, m_lRowJump >> 2);
}
}
else
{
retVal = HXR_FAIL;
}
}
else
{
retVal = HXR_NOT_INITIALIZED;
}
}
else
{
retVal = HXR_INVALID_PARAMETER;
}
return retVal;
}
HX_RESULT PXImage::FlipTo(PXImage* pImg, BOOL bVerticalAxis)
{
HX_RESULT retVal = HXR_OK;
if (pImg)
{
if (m_bInitialized)
{
if (Compatible(pImg) && SameSize(pImg))
{
if (bVerticalAxis)
{
VertAxisFlip32((UINT32*) m_pImageBuffer, m_lSubImageWidth,
m_lSubImageHeight, m_lRowJump >> 2,
(UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
pImg->m_lSubImageHeight, pImg->m_lRowJump >> 2);
}
else
{
HorzAxisFlip32((UINT32*) m_pImageBuffer, m_lSubImageWidth,
m_lSubImageHeight, m_lRowJump >> 2,
(UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
pImg->m_lSubImageHeight, pImg->m_lRowJump >> 2);
}
}
else
{
retVal = HXR_FAIL;
}
}
else
{
retVal = HXR_NOT_INITIALIZED;
}
}
else
{
retVal = HXR_INVALID_PARAMETER;
}
return retVal;
}
HX_RESULT PXImage::Wipe(PXImage* pStartImg, PXImage* pEndImg, UINT32 ulType,
UINT32 ulDirection, UINT32 ulTime, UINT32 ulDuration)
{
HX_RESULT retVal = HXR_OK;
if (pStartImg &&
pEndImg &&
(ulType == PXEffect::kWipeTypeNormal ||
ulType == PXEffect::kWipeTypePush) &&
(ulDirection == PXEffect::kWipeDirectionUp ||
ulDirection == PXEffect::kWipeDirectionDown ||
ulDirection == PXEffect::kWipeDirectionLeft ||
ulDirection == PXEffect::kWipeDirectionRight) &&
ulTime > 0 &&
ulTime < ulDuration &&
ulDuration > 0)
{
if (m_bInitialized)
{
if (Compatible(pStartImg) && SameSize(pStartImg) &&
Compatible(pEndImg) && SameSize(pEndImg))
{
// Set up src and dst rectangles for both
// the start and end images
PXRect cStartSrc;
PXRect cStartDst;
PXRect cEndSrc;
PXRect cEndDst;
UINT32 ulW = pStartImg->GetWidth();
UINT32 ulH = pStartImg->GetHeight();
if (ulType == PXEffect::kWipeTypeNormal)
{
if (ulDirection == PXEffect::kWipeDirectionUp)
{
UINT32 ulY = (ulDuration - ulTime) * ulH / ulDuration;
cStartSrc.Set(0, 0, ulW, ulY);
cEndSrc.Set(0, ulY, ulW, ulH - ulY);
}
else if (ulDirection == PXEffect::kWipeDirectionDown)
{
UINT32 ulY = ulTime * ulH / ulDuration;
cStartSrc.Set(0, ulY, ulW, ulH - ulY);
cEndSrc.Set(0, 0, ulW, ulY);
}
else if (ulDirection == PXEffect::kWipeDirectionLeft)
{
UINT32 ulX = (ulDuration - ulTime) * ulW / ulDuration;
cStartSrc.Set(0, 0, ulX, ulH);
cEndSrc.Set(ulX, 0, ulW - ulX, ulH);
}
else if (ulDirection == PXEffect::kWipeDirectionRight)
{
UINT32 ulX = ulTime * ulW / ulDuration;
cStartSrc.Set(ulX, 0, ulW - ulX, ulH);
cEndSrc.Set(0, 0, ulX, ulH);
}
cStartDst = cStartSrc;
cEndDst = cEndSrc;
}
else
{
if (ulDirection == PXEffect::kWipeDirectionUp)
{
UINT32 ulY = (ulDuration - ulTime) * ulH / ulDuration;
cStartSrc.Set(0, ulH - ulY, ulW, ulY);
cStartDst.Set(0, 0, ulW, ulY);
cEndSrc.Set(0, 0, ulW, ulH - ulY);
cEndDst.Set(0, ulY, ulW, ulH - ulY);
}
else if (ulDirection == PXEffect::kWipeDirectionDown)
{
UINT32 ulY = ulTime * ulH / ulDuration;
cStartSrc.Set(0, 0, ulW, ulH - ulY);
cStartDst.Set(0, ulY, ulW, ulH - ulY);
cEndSrc.Set(0, ulH - ulY, ulW, ulY);
cEndDst.Set(0, 0, ulW, ulY);
}
else if (ulDirection == PXEffect::kWipeDirectionLeft)
{
UINT32 ulX = (ulDuration - ulTime) * ulW / ulDuration;
cStartSrc.Set(ulW - ulX, 0, ulX, ulH);
cStartDst.Set(0, 0, ulX, ulH);
cEndSrc.Set(0, 0, ulW - ulX, ulH);
cEndDst.Set(ulX, 0, ulW - ulX, ulH);
}
else if (ulDirection == PXEffect::kWipeDirectionRight)
{
UINT32 ulX = ulTime * ulW / ulDuration;
cStartSrc.Set(0, 0, ulW - ulX, ulH);
cStartDst.Set(ulX, 0, ulW - ulX, ulH);
cEndSrc.Set(ulW - ulX, 0,ulX, ulH);
cEndDst.Set(0, 0, ulX, ulH);
}
}
// Copy from the start image
if (cStartSrc.GetWidth() > 0 && cStartSrc.GetHeight() > 0)
{
// Create the start src image
PXImage cStartSrcImg;
retVal = cStartSrcImg.CreateSubImage(pStartImg, cStartSrc);
if (SUCCEEDED(retVal))
{
// Create the start dst image
PXImage cStartDstImg;
retVal = cStartDstImg.CreateSubImage(this, cStartDst);
if (SUCCEEDED(retVal))
{
// Now copy the start image
retVal = cStartDstImg.CopyFrom(&cStartSrcImg);
}
}
}
if (SUCCEEDED(retVal))
{
// Copy from the dst image
if (cEndSrc.GetWidth() > 0 && cEndSrc.GetHeight() > 0)
{
// Create the end src image
PXImage cEndSrcImg;
retVal = cEndSrcImg.CreateSubImage(pEndImg, cEndSrc);
if (SUCCEEDED(retVal))
{
// Create the end dst image
PXImage cEndDstImg;
retVal = cEndDstImg.CreateSubImage(this, cEndDst);
if (SUCCEEDED(retVal))
{
// Now copy the end image
retVal = cEndDstImg.CopyFrom(&cEndSrcImg);
}
}
}
}
}
else
{
retVal = HXR_FAIL;
}
}
else
{
retVal = HXR_NOT_INITIALIZED;
}
}
else
{
retVal = HXR_INVALID_PARAMETER;
}
return retVal;
}
HX_RESULT PXImage::RecursiveWipe(PXImage* pEndImage, UINT32 ulType, UINT32 ulDirection, UINT32 ulLastTime,
UINT32 ulTime, UINT32 ulDuration, PXRect& rDamageRect)
{
HX_RESULT retVal = HXR_OK;
if (pEndImage &&
(ulType == PXEffect::kWipeTypeNormal ||
ulType == PXEffect::kWipeTypePush) &&
(ulDirection == PXEffect::kWipeDirectionUp ||
ulDirection == PXEffect::kWipeDirectionDown ||
ulDirection == PXEffect::kWipeDirectionLeft ||
ulDirection == PXEffect::kWipeDirectionRight) &&
ulTime > 0 &&
ulTime < ulDuration &&
ulTime > ulLastTime &&
ulDuration > 0)
{
if (m_bInitialized)
{
if (Compatible(pEndImage) && SameSize(pEndImage))
{
// Set up src and dst rectangles for both
// the start and end images
UINT32 ulW = pEndImage->GetWidth();
UINT32 ulH = pEndImage->GetHeight();
if (ulType == PXEffect::kWipeTypeNormal)
{
PXRect cRect;
if (ulDirection == PXEffect::kWipeDirectionUp)
{
UINT32 ulY = (ulDuration - ulTime) * ulH / ulDuration;
UINT32 ulLastY = (ulDuration - ulLastTime) * ulH / ulDuration;
cRect.Set(0, ulY, ulW, ulLastY - ulY);
}
else if (ulDirection == PXEffect::kWipeDirectionDown)
{
UINT32 ulY = ulTime * ulH / ulDuration;
UINT32 ulLastY = ulLastTime * ulH / ulDuration;
cRect.Set(0, ulLastY, ulW, ulY - ulLastY);
}
else if (ulDirection == PXEffect::kWipeDirectionLeft)
{
UINT32 ulX = (ulDuration - ulTime) * ulW / ulDuration;
UINT32 ulLastX = (ulDuration - ulLastTime) * ulW / ulDuration;
cRect.Set(ulX, 0, ulLastX - ulX, ulH);
}
else if (ulDirection == PXEffect::kWipeDirectionRight)
{
UINT32 ulX = ulTime * ulW / ulDuration;
UINT32 ulLastX = ulLastTime * ulW / ulDuration;
cRect.Set(ulLastX, 0, ulX - ulLastX, ulH);
}
// Make sure that we have something to copy
if (cRect.GetWidth() > 0 && cRect.GetHeight() > 0)
{
// Set up the source image
PXImage cEndSrcImg;
retVal = cEndSrcImg.CreateSubImage(pEndImage, cRect);
if (SUCCEEDED(retVal))
{
// Set up the destination image
PXImage cEndDstImg;
retVal = cEndDstImg.CreateSubImage(this, cRect);
if (SUCCEEDED(retVal))
{
retVal = cEndDstImg.CopyFrom(&cEndSrcImg);
if (SUCCEEDED(retVal))
{
rDamageRect = cRect;
}
}
}
}
}
else
{
PXRect cIntraSrcRect;
PXRect cIntraDstRect;
PXRect cEndSrcRect;
PXRect cEndDstRect;
if (ulDirection == PXEffect::kWipeDirectionUp)
{
UINT32 ulY = (ulDuration - ulTime) * ulH / ulDuration;
UINT32 ulLastY = (ulDuration - ulLastTime) * ulH / ulDuration;
UINT32 ulYDiff = ulLastY - ulY;
cIntraSrcRect.Set(0, ulYDiff, ulW, ulH - ulYDiff);
cIntraDstRect.Set(0, 0, ulW, ulH - ulYDiff);
cEndSrcRect.Set(0, ulH - ulLastY, ulW, ulYDiff);
cEndDstRect.Set(0, ulH - ulYDiff, ulW, ulYDiff);
}
else if (ulDirection == PXEffect::kWipeDirectionDown)
{
UINT32 ulY = ulTime * ulH / ulDuration;
UINT32 ulLastY = ulLastTime * ulH / ulDuration;
UINT32 ulYDiff = ulY - ulLastY;
cIntraSrcRect.Set(0, 0, ulW, ulH - ulYDiff);
cIntraDstRect.Set(0, ulYDiff, ulW, ulH - ulYDiff);
cEndSrcRect.Set(0, ulH - ulY, ulW, ulYDiff);
cEndDstRect.Set(0, 0, ulW, ulYDiff);
}
else if (ulDirection == PXEffect::kWipeDirectionLeft)
{
UINT32 ulX = (ulDuration - ulTime) * ulW / ulDuration;
UINT32 ulLastX = (ulDuration - ulLastTime) * ulW / ulDuration;
UINT32 ulXDiff = ulLastX - ulX;
cIntraSrcRect.Set(ulXDiff, 0, ulW - ulXDiff, ulH);
cIntraDstRect.Set(0, 0, ulW - ulXDiff, ulH);
cEndSrcRect.Set(ulW - ulLastX, 0, ulXDiff, ulH);
cEndDstRect.Set(ulW - ulXDiff, 0, ulXDiff, ulH);
}
else if (ulDirection == PXEffect::kWipeDirectionRight)
{
UINT32 ulX = ulTime * ulW / ulDuration;
UINT32 ulLastX = ulLastTime * ulW / ulDuration;
UINT32 ulXDiff = ulX - ulLastX;
cIntraSrcRect.Set(0, 0, ulW - ulXDiff, ulH);
cIntraDstRect.Set(ulXDiff, 0, ulW - ulXDiff, ulH);
cEndSrcRect.Set(ulW - ulX, 0, ulXDiff, ulH);
cEndDstRect.Set(0, 0, ulXDiff, ulH);
}
// Make sure we have something to copy
if (cIntraSrcRect.GetWidth() == 0 || cIntraSrcRect.GetHeight() == 0)
{
// This is all end image, so just do a copy
retVal = CopyFrom(pEndImage);
}
else if (cEndSrcRect.GetWidth() > 0 && cEndSrcRect.GetHeight() > 0)
{
// First we do an intra copy to copy the part of
// the image which is already there.
retVal = IntraCopy(cIntraSrcRect, cIntraDstRect);
if (SUCCEEDED(retVal))
{
PXImage cEndSrcImg;
retVal = cEndSrcImg.CreateSubImage(pEndImage, cEndSrcRect);
if (SUCCEEDED(retVal))
{
PXImage cEndDstImg;
retVal = cEndDstImg.CreateSubImage(this, cEndDstRect);
if (SUCCEEDED(retVal))
{
retVal = cEndDstImg.CopyFrom(&cEndSrcImg);
if (SUCCEEDED(retVal))
{
rDamageRect.Set(0, 0, ulW, ulH);
}
}
}
}
}
}
}
else
{
retVal = HXR_FAIL;
}
}
else
{
retVal = HXR_NOT_INITIALIZED;
}
}
else
{
retVal = HXR_INVALID_PARAMETER;
}
⌨️ 快捷键说明
复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?