Modifed eglbringuptest to compile against S^3 SDK; added a pkg file
The S^3 SDK lacks libopenvgu.lib. Since this test app does not require
that library, it is simply removed from the .mmp file.
// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
#include "BMDRAW.H"
//Initializes iSize, iDrawRect, iLongWidth, iScanLineBytes, iScanlineWords data members.
//It should be called every time when iSize is going to be changed - from Construct().
//@param aSize Physical screen size in pixels.
//@panic EScreenDriverPanicInvalidSize - Invalid aSize parameter. This might happen if the
//device is scaled and the scaling origin goes outside physical drawing rectangle.
void CDrawTwentyFourBppBitmap::SetSize(const TSize& aSize)
{
CDrawBitmap::SetSize(aSize);
__ASSERT_DEBUG(iSize == aSize, User::Invariant());
iScanLineBytes = (((iSize.iWidth * 3) + 11) / 12) * 12;
iLongWidth = iScanLineBytes / 3;
iScanLineWords = iScanLineBytes / 4;
}
TInt CDrawTwentyFourBppBitmap::Construct(TSize aSize)
{
return Construct(aSize, (((aSize.iWidth * 3) + 11) / 12) * 12);
}
TInt CDrawTwentyFourBppBitmap::Construct(TSize aSize, TInt aStride)
{
iBits = NULL;
iDispMode = EColor16M;
CDrawBitmap::SetSize(aSize);
__ASSERT_DEBUG(iSize == aSize, User::Invariant());
if (aStride % 12)
return KErrArgument;
iScanLineBytes = aStride;
iLongWidth = aStride / 3;
if (iLongWidth < aSize.iWidth)
return KErrArgument;
iScanLineWords = aStride >> 2;
TInt size = (((Max(aSize.iWidth,aSize.iHeight) * 3) + 11) / 12) * 12;
if(size < 0)
return KErrArgument;
iScanLineBuffer = (TUint32*)(User::Heap().Alloc(size));
if (iScanLineBuffer == NULL)
return KErrNoMemory;
return KErrNone;
}
inline TInt CDrawTwentyFourBppBitmap::PixelAddressIncrement() const
{
switch (iOrientation)
{
case EOrientationNormal:
return 3;
case EOrientationRotated90:
return iScanLineBytes;
case EOrientationRotated180:
return -3;
case EOrientationRotated270:
return -iScanLineBytes;
default:
return 1;
}
}
inline void CDrawTwentyFourBppBitmap::PixelAddressIncrement(TInt& aPixelInc,TInt& aRowInc) const
{
switch (iOrientation)
{
case EOrientationNormal:
aPixelInc = 3;
aRowInc = iScanLineBytes;
break;
case EOrientationRotated90:
aPixelInc = iScanLineBytes;
aRowInc = -3;
break;
case EOrientationRotated180:
aPixelInc = -3;
aRowInc = -iScanLineBytes;
break;
case EOrientationRotated270:
aPixelInc = -iScanLineBytes;
aRowInc = 3;
break;
default:
aPixelInc = 1;
aRowInc = 1;
}
}
void CDrawTwentyFourBppBitmap::FadeRgb(TInt& red,TInt& green,TInt& blue)
{
blue = ((blue * iFadeMapFactor) >> 8) + iFadeMapOffset;
green = ((green * iFadeMapFactor) >> 16) + iFadeMapOffset;
red = ((red * iFadeMapFactor) >> 8) + iFadeMapOffset;
}
void CDrawTwentyFourBppBitmap::Shadow(TRgb& aColor)
{
if (iShadowMode & EFade)
aColor = CDrawBitmap::FadeRgb(aColor);
if (iShadowMode & EShadow)
{
TInt r = ShadowComponentInl(aColor.Red());
TInt g = ShadowComponentInl(aColor.Green());
TInt b = ShadowComponentInl(aColor.Blue());
aColor = TRgb(r,g,b);
}
}
void CDrawTwentyFourBppBitmap::Shadow(TInt& red,TInt& green,TInt& blue)
{
if (iShadowMode & EFade)
FadeRgb(red,green,blue);
if (iShadowMode & EShadow)
{
red = ShadowComponentInl(red);
green = ShadowComponentInl(green);
blue = ShadowComponentInl(blue);
}
}
TUint8 CDrawTwentyFourBppBitmap::ShadowAndFade(TInt aComponent)
{
if (iShadowMode & EFade)
aComponent = FadeGray(aComponent);
if (iShadowMode & EShadow)
aComponent = ShadowComponentInl(aComponent);
return TUint8(aComponent);
}
TUint8 CDrawTwentyFourBppBitmap::ShadowComponentInl(TInt aRgbComponent)
{
return TUint8(Max(0,aRgbComponent-0x40));
}
TUint8 CDrawTwentyFourBppBitmap::ShadowComponent(TInt aRgbComponent)
{
return ShadowComponentInl(aRgbComponent);
}
void CDrawTwentyFourBppBitmap::InvertBuffer(TInt aLength,TUint32* aBuffer)
{
__ASSERT_DEBUG(aLength>0,Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));
TUint8* buffer = (TUint8*)aBuffer;
TUint8* limit = buffer + (aLength * 3);
while (buffer < limit)
*buffer++ ^= 0xff;
}
void CDrawTwentyFourBppBitmap::ReadLine(TInt aX,TInt aY,TInt aLength,TAny* aBuffer) const
{
const TUint8* pixelPtr = PixelAddress(aX,aY);
if (iOrientation == EOrientationNormal)
Mem::Copy(aBuffer,pixelPtr,aLength * 3);
else
{
const TInt pixelPtrInc = PixelAddressIncrement();
TUint8* bufferPtr = STATIC_CAST(TUint8*,aBuffer);
const TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);
while (bufferPtr < bufferPtrLimit)
{
*bufferPtr++ = pixelPtr[0];
*bufferPtr++ = pixelPtr[1];
*bufferPtr++ = pixelPtr[2];
pixelPtr += pixelPtrInc;
}
}
}
TRgb CDrawTwentyFourBppBitmap::ReadRgbNormal(TInt aX,TInt aY) const
{
TUint8* pixelPtr = PixelAddress(aX,aY);
return TRgb(pixelPtr[2],pixelPtr[1],pixelPtr[0]);
}
void CDrawTwentyFourBppBitmap::ShadowArea(const TRect& aRect)
{
const TRect rect(DeOrientate(aRect));
__ASSERT_DEBUG(rect.iTl.iX>=0 && rect.iBr.iX<=iSize.iWidth,Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(rect.iTl.iY>=0 && rect.iBr.iY<=iSize.iHeight,Panic(EScreenDriverPanicOutOfBounds));
TUint8* pixelPtr = PixelAddress(rect.iTl.iX,rect.iTl.iY);
TUint8* pixelRowPtrLimit = pixelPtr + (rect.Height() * iScanLineBytes);
if (iShadowMode & EFade)
{
TUint8* pixelRowPtr = pixelPtr;
TUint8* pixelPtrLimit = pixelPtr + (rect.Width() * 3);
while (pixelRowPtr < pixelRowPtrLimit)
{
TUint8* tempPixelPtr = pixelRowPtr;
while (tempPixelPtr < pixelPtrLimit)
{
*tempPixelPtr = FadeGray(*tempPixelPtr);
++tempPixelPtr;
}
pixelRowPtr += iScanLineBytes;
pixelPtrLimit += iScanLineBytes;
}
}
if (iShadowMode & EShadow)
{
TUint8* pixelRowPtr = pixelPtr;
TUint8* pixelPtrLimit = pixelPtr + (rect.Width() * 3);
while (pixelRowPtr < pixelRowPtrLimit)
{
TUint8* tempPixelPtr = pixelRowPtr;
while (tempPixelPtr < pixelPtrLimit)
{
*tempPixelPtr = ShadowComponent(*tempPixelPtr);
++tempPixelPtr;
}
pixelRowPtr += iScanLineBytes;
pixelPtrLimit += iScanLineBytes;
}
}
}
void CDrawTwentyFourBppBitmap::ShadowBuffer(TInt aLength,TUint32* aBuffer)
{
__ASSERT_DEBUG(aLength>0,Panic(EScreenDriverPanicZeroLength));
__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));
TUint8* limit = ((TUint8*)aBuffer) + (aLength * 3);
if (iShadowMode & EFade)
{
TUint8* buffer = (TUint8*)aBuffer;
while (buffer < limit)
{
*buffer = FadeGray(*buffer);
++buffer;
}
}
if (iShadowMode & EShadow)
{
TUint8* buffer = (TUint8*)aBuffer;
while (buffer < limit)
{
*buffer = ShadowComponent(*buffer);
++buffer;
}
}
}
void CDrawTwentyFourBppBitmap::WriteRgb(TInt aX,TInt aY,TRgb aColor)
{
TUint8* pixelPtr = PixelAddress(aX,aY);
pixelPtr[0] = TUint8(aColor.Blue());
pixelPtr[1] = TUint8(aColor.Green());
pixelPtr[2] = TUint8(aColor.Red());
}
void CDrawTwentyFourBppBitmap::WriteBinary(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor)
{
DeOrientate(aX,aY);
TInt pixelInc;
TInt rowInc;
PixelAddressIncrement(pixelInc,rowInc);
const TUint32* dataLimit = aBuffer + aHeight;
const TUint32 dataMaskLimit = (aLength < 32) ? 1 << aLength : 0;
TUint8* pixelPtr = PixelAddress(aX,aY);
const TUint8 r = (TUint8)aColor.Red();
const TUint8 g = (TUint8)aColor.Green();
const TUint8 b = (TUint8)aColor.Blue();
while (aBuffer < dataLimit)
{
TUint32 dataWord = *aBuffer++;
TUint32 dataMask = 1;
TUint8* tempPixelPtr = pixelPtr;
while (dataMask != dataMaskLimit)
{
if(dataWord & dataMask)
{
tempPixelPtr[0] = b;
tempPixelPtr[1] = g;
tempPixelPtr[2] = r;
}
tempPixelPtr += pixelInc;
dataMask <<= 1;
}
pixelPtr += rowInc;
}
}
void CDrawTwentyFourBppBitmap::WriteBinaryOp(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode)
{
if (aLength <= 0)
return;
DeOrientate(aX,aY);
TUint8* pixelPtr = PixelAddress(aX,aY);
const TUint32* dataPtrLimit = aBuffer + aHeight;
const TUint32 dataMaskLimit = (aLength < 32) ? 1 << aLength : 0;
TInt pixelInc;
TInt rowInc;
PixelAddressIncrement(pixelInc,rowInc);
const TUint8 r = (TUint8)aColor.Red();
const TUint8 g = (TUint8)aColor.Green();
const TUint8 b = (TUint8)aColor.Blue();
if (r || g || b)
{
while (aBuffer < dataPtrLimit)
{
TUint32 dataWord = *aBuffer++;
TUint32 dataMask = 1;
TUint8* tempPixelPtr = pixelPtr;
while (dataMask != dataMaskLimit)
{
if(dataWord & dataMask)
{
switch (aDrawMode)
{
case CGraphicsContext::EDrawModeXOR:
tempPixelPtr[0] ^= b;
tempPixelPtr[1] ^= g;
tempPixelPtr[2] ^= r;
break;
case CGraphicsContext::EDrawModeAND:
tempPixelPtr[0] &= b;
tempPixelPtr[1] &= g;
tempPixelPtr[2] &= r;
break;
case CGraphicsContext::EDrawModeOR:
tempPixelPtr[0] |= b;
tempPixelPtr[1] |= g;
tempPixelPtr[2] |= r;
break;
default:
break;
}
}
tempPixelPtr += pixelInc;
dataMask <<= 1;
}
pixelPtr += rowInc;
}
}
else if (aDrawMode == CGraphicsContext::EDrawModeAND)
{
while (aBuffer < dataPtrLimit)
{
TUint32 dataWord = *aBuffer++;
TUint32 dataMask = 1;
TUint8* tempPixelPtr = pixelPtr;
while (dataMask != dataMaskLimit)
{
if(dataWord & dataMask)
{
tempPixelPtr[0] = 0;
tempPixelPtr[1] = 0;
tempPixelPtr[2] = 0;
}
tempPixelPtr += pixelInc;
dataMask <<= 1;
}
pixelPtr += rowInc;
}
}
}
void CDrawTwentyFourBppBitmap::WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aBuffer,TInt aHeight,TRgb aColor,TBool aUp)
{
DeOrientate(aX,aY);
TInt scanlineByteLength;
switch (iOrientation)
{
case EOrientationNormal:
scanlineByteLength = iScanLineBytes;
break;
case EOrientationRotated90:
scanlineByteLength = -3;
break;
case EOrientationRotated180:
scanlineByteLength = -iScanLineBytes;
break;
default: // EOrientationRotated270
scanlineByteLength = 3;
break;
}
if (aUp)
scanlineByteLength = -scanlineByteLength;
TUint8* pixelPtr = PixelAddress(aX,aY);
const TUint8* pixelPtrLimit = pixelPtr + (aHeight * scanlineByteLength);
TUint32 dataWord = *aBuffer;
TUint32 dataMask = 1;
const TUint8 r = (TUint8)aColor.Red();
const TUint8 g = (TUint8)aColor.Green();
const TUint8 b = (TUint8)aColor.Blue();
while(pixelPtr != pixelPtrLimit)
{
if(!dataMask)
{
dataMask = 1;
aBuffer++;
dataWord = *aBuffer;
}
if(dataWord & dataMask)
{
pixelPtr[0] = b;
pixelPtr[1] = g;
pixelPtr[2] = r;
}
dataMask <<= 1;
pixelPtr += scanlineByteLength;
}
}
void CDrawTwentyFourBppBitmap::WriteLine(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)
{
TUint8* pixelPtr = PixelAddress(aX,aY);
if (iOrientation == EOrientationNormal)
Mem::Copy(pixelPtr,aBuffer,aLength * 3);
else
{
const TInt pixelPtrInc = PixelAddressIncrement();
TUint8* bufferPtr = REINTERPRET_CAST(TUint8*,aBuffer);
TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);
while (bufferPtr < bufferPtrLimit)
{
pixelPtr[0] = *bufferPtr++;
pixelPtr[1] = *bufferPtr++;
pixelPtr[2] = *bufferPtr++;
pixelPtr += pixelPtrInc;
}
}
}
void CDrawTwentyFourBppBitmap::WriteLineXOR(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)
{
TUint8* pixelPtr = PixelAddress(aX,aY);
const TInt pixelPtrInc = PixelAddressIncrement();
TUint8* bufferPtr = REINTERPRET_CAST(TUint8*,aBuffer);
TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);
while (bufferPtr < bufferPtrLimit)
{
pixelPtr[0] ^= *bufferPtr++;
pixelPtr[1] ^= *bufferPtr++;
pixelPtr[2] ^= *bufferPtr++;
pixelPtr += pixelPtrInc;
}
}
void CDrawTwentyFourBppBitmap::WriteLineAND(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)
{
TUint8* pixelPtr = PixelAddress(aX,aY);
const TInt pixelPtrInc = PixelAddressIncrement();
TUint8* bufferPtr = REINTERPRET_CAST(TUint8*,aBuffer);
TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);
while (bufferPtr < bufferPtrLimit)
{
pixelPtr[0] &= *bufferPtr++;
pixelPtr[1] &= *bufferPtr++;
pixelPtr[2] &= *bufferPtr++;
pixelPtr += pixelPtrInc;
}
}
void CDrawTwentyFourBppBitmap::WriteLineOR(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)
{
TUint8* pixelPtr = PixelAddress(aX,aY);
const TInt pixelPtrInc = PixelAddressIncrement();
TUint8* bufferPtr = REINTERPRET_CAST(TUint8*,aBuffer);
TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);
while (bufferPtr < bufferPtrLimit)
{
pixelPtr[0] |= *bufferPtr++;
pixelPtr[1] |= *bufferPtr++;
pixelPtr[2] |= *bufferPtr++;
pixelPtr += pixelPtrInc;
}
}
/**
MAlphaBlend::WriteRgbAlphaLine() implementation.
@see MAlphaBlend::WriteRgbAlphaLine()
*/
void CDrawTwentyFourBppBitmap::WriteRgbAlphaLine(TInt aX, TInt aY, TInt aLength,
const TUint8* aRgbBuffer,
const TUint8* aMaskBuffer,
MAlphaBlend::TShadowing aShadowing,
CGraphicsContext::TDrawMode /*aDrawMode*/)
{
DeOrientate(aX,aY);
TUint8* pixelPtr = PixelAddress(aX,aY);
const TInt pixelPtrInc = PixelAddressIncrement();
const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;
while (aMaskBuffer < maskBufferPtrLimit)
{
TInt mask = aMaskBuffer[0];
if(mask)
{
TInt red = aRgbBuffer[2];
TInt green = aRgbBuffer[1];
TInt blue = aRgbBuffer[0];
if(aShadowing == MAlphaBlend::EShdwBefore)
{
Shadow(red,green,blue);
}
if(aMaskBuffer[0] != 0xff) // Blend 24bpp
{
mask = mask * 257;
red = (((red - pixelPtr[2]) * mask) >> 16) + pixelPtr[2];
green = (((green - pixelPtr[1]) * mask) >> 16) + pixelPtr[1];
blue = (((blue - pixelPtr[0]) * mask) >> 16) + pixelPtr[0];
}
if(aShadowing == MAlphaBlend::EShdwAfter)
{
Shadow(red,green,blue);
}
CDrawBitmap::MapColorToUserDisplayMode(red,green,blue);
pixelPtr[0] = TUint8(blue);
pixelPtr[1] = TUint8(green);
pixelPtr[2] = TUint8(red);
}
pixelPtr += pixelPtrInc;
aRgbBuffer += 4;
aMaskBuffer++;
}
}
const TUint32 KWordAlignedCount = 4;
const TUint32 KWordAlignedMask = 3;
const TUint32 KFinishEarlyByThree = 3;
void WriteTwentyFourBppColourAsWords(TUint8& r, TUint8& g, TUint8& b, TUint8* pixelPtr, const TInt byteLength, TUint8* pixelRowPtrLimit, const TInt scanLineBytes)
{
TUint8 bgr[3] =
{
b,g,r
};
TUint32 bgrb = b+(g<<8)+(r<<16)+(b<<24);
TUint32 grbg = g+(r<<8)+(b<<16)+(g<<24);
TUint32 rbgr = r+(b<<8)+(g<<16)+(r<<24);
TUint8* pixelPtrLimit = pixelPtr + byteLength;
TInt leadingPixels = KWordAlignedCount-((TUint32)pixelPtr)&KWordAlignedMask;
if (leadingPixels == KWordAlignedCount)
leadingPixels = 0;
const TInt trailingPixels = ((TUint32)pixelPtrLimit & KWordAlignedMask);
while (pixelPtr < pixelRowPtrLimit)
{
TUint8* tempPixelPtr;
TUint32* tempWordPtr;
TInt nextOfBgr = 0;
TUint8* leadingPixelPtrLimit = pixelPtr+leadingPixels;
for (tempPixelPtr = pixelPtr; tempPixelPtr < leadingPixelPtrLimit; tempPixelPtr++)
{
tempPixelPtr[0] = bgr[nextOfBgr++];
}
if (nextOfBgr == (KWordAlignedCount-1))
nextOfBgr = 0;
TUint32* wordPtrLimit = ((TUint32*)(pixelPtrLimit-trailingPixels))-KFinishEarlyByThree;
tempWordPtr = (TUint32*)tempPixelPtr;
switch (nextOfBgr)
{
case 1:
if (tempWordPtr < wordPtrLimit)
{
*tempWordPtr++ = grbg;
nextOfBgr = 2;
}
//no break
case 2:
if (tempWordPtr < wordPtrLimit)
{
*tempWordPtr++ = rbgr;
nextOfBgr = 0;
}
}
while (tempWordPtr < wordPtrLimit)
{
*tempWordPtr++ = bgrb;
*tempWordPtr++ = grbg;
*tempWordPtr++ = rbgr;
}
for (tempPixelPtr = (TUint8*)tempWordPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr++)
{
tempPixelPtr[0] = bgr[nextOfBgr++];
if (nextOfBgr > 2)
nextOfBgr = 0;
}
pixelPtr += scanLineBytes;
pixelPtrLimit += scanLineBytes;
}
}
/**
Writes a specific colour to the screen, optimised to use mem fill if the colour is shade of grey
and word aligned access the three possible combinations of the colour bytes.
*/
void CDrawTwentyFourBppBitmap::WriteRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)
{
const TInt scanLineBytes = iScanLineBytes;
const TInt byteLength = aLength * 3;
TUint8* pixelPtr = PixelAddress(aX,aY);
TUint8* pixelRowPtrLimit = pixelPtr + (aHeight * scanLineBytes);
TUint8 r = TUint8(aColor.Red());
TUint8 g = TUint8(aColor.Green());
TUint8 b = TUint8(aColor.Blue());
if ((r == g) && (g == b))
{
while (pixelPtr < pixelRowPtrLimit)
{
Mem::Fill(pixelPtr,byteLength,r);
pixelPtr += scanLineBytes;
}
}
else
{
WriteTwentyFourBppColourAsWords(r, g, b, pixelPtr, byteLength, pixelRowPtrLimit, scanLineBytes);
}
}
void CDrawTwentyFourBppBitmap::WriteRgbMultiXOR(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)
{
TUint8* pixelPtr = PixelAddress(aX,aY);
TUint8* pixelPtrLimit = pixelPtr + (aLength * 3);
TUint8* pixelRowPtrLimit = pixelPtr + (aHeight * iScanLineBytes);
TUint8 r = TUint8(aColor.Red());
TUint8 g = TUint8(aColor.Green());
TUint8 b = TUint8(aColor.Blue());
while (pixelPtr < pixelRowPtrLimit)
{
for (TUint8* tempPixelPtr = pixelPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr += 3)
{
tempPixelPtr[0] ^= b;
tempPixelPtr[1] ^= g;
tempPixelPtr[2] ^= r;
}
pixelPtr += iScanLineBytes;
pixelPtrLimit += iScanLineBytes;
}
}
void CDrawTwentyFourBppBitmap::WriteRgbMultiAND(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)
{
TUint8* pixelPtr = PixelAddress(aX,aY);
TUint8* pixelPtrLimit = pixelPtr + (aLength * 3);
TUint8* pixelRowPtrLimit = pixelPtr + (aHeight * iScanLineBytes);
TUint8 r = TUint8(aColor.Red());
TUint8 g = TUint8(aColor.Green());
TUint8 b = TUint8(aColor.Blue());
while (pixelPtr < pixelRowPtrLimit)
{
for (TUint8* tempPixelPtr = pixelPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr += 3)
{
tempPixelPtr[0] &= b;
tempPixelPtr[1] &= g;
tempPixelPtr[2] &= r;
}
pixelPtr += iScanLineBytes;
pixelPtrLimit += iScanLineBytes;
}
}
void CDrawTwentyFourBppBitmap::WriteRgbMultiOR(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)
{
TUint8* pixelPtr = PixelAddress(aX,aY);
TUint8* pixelPtrLimit = pixelPtr + (aLength * 3);
TUint8* pixelRowPtrLimit = pixelPtr + (aHeight * iScanLineBytes);
TUint8 r = TUint8(aColor.Red());
TUint8 g = TUint8(aColor.Green());
TUint8 b = TUint8(aColor.Blue());
while (pixelPtr < pixelRowPtrLimit)
{
for (TUint8* tempPixelPtr = pixelPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr += 3)
{
tempPixelPtr[0] |= b;
tempPixelPtr[1] |= g;
tempPixelPtr[2] |= r;
}
pixelPtr += iScanLineBytes;
pixelPtrLimit += iScanLineBytes;
}
}
void CDrawTwentyFourBppBitmap::WriteRgbAlphaMulti(TInt aX,TInt aY,TInt aLength,TRgb aColor,const TUint8* aMaskBuffer)
{
DeOrientate(aX,aY);
TUint8* pixelPtr = PixelAddress(aX,aY);
const TInt pixelPtrInc = PixelAddressIncrement();
const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;
if (iShadowMode)
Shadow(aColor);
const TInt red = aColor.Red();
const TInt green = aColor.Green();
const TInt blue = aColor.Blue();
while (aMaskBuffer < maskBufferPtrLimit)
{
if(aMaskBuffer[0])
{
TRgb pixelClr;
if(aMaskBuffer[0] != 0xff)
{
pixelClr = AlphaBlend(red, green, blue, TRgb(pixelPtr[2], pixelPtr[1], pixelPtr[0]), aMaskBuffer[0]);
}
else
{
pixelClr = aColor;
}
pixelPtr[0] = TUint8(pixelClr.Blue());
pixelPtr[1] = TUint8(pixelClr.Green());
pixelPtr[2] = TUint8(pixelClr.Red());
}
pixelPtr += pixelPtrInc;
aMaskBuffer++;
}
}
void CDrawTwentyFourBppBitmap::MapColorToUserDisplayMode(TRgb& aColor)
{
switch (iUserDispMode)
{
case EGray2:
aColor = TRgb::_Gray2(aColor._Gray2());
break;
case EGray4:
aColor = TRgb::_Gray4(aColor._Gray4());
break;
case EGray16:
aColor = TRgb::_Gray16(aColor._Gray16());
break;
case EGray256:
aColor = TRgb::_Gray256(aColor._Gray256());
break;
case EColor16:
aColor = TRgb::Color16(aColor.Color16());
break;
case EColor256:
aColor = TRgb::Color256(aColor.Color256());
break;
case EColor4K:
aColor = TRgb::_Color4K(aColor._Color4K());
break;
case EColor64K:
aColor = TRgb::_Color64K(aColor._Color64K());
break;
default:
break;
}
}
void CDrawTwentyFourBppBitmap::MapBufferToUserDisplayMode(TInt aLength,TUint32* aBuffer)
{
TUint8* bufferPtr = (TUint8*)aBuffer;
const TUint8* bufferLimit = bufferPtr + (aLength * 3);
switch (iUserDispMode)
{
case EGray2:
while (bufferPtr < bufferLimit)
{
TInt blue = bufferPtr[0];
TInt green = bufferPtr[1];
TInt red = bufferPtr[2];
TRgb color(red,green,blue);
color = TRgb::_Gray2(color._Gray2());
bufferPtr[0] = TUint8(color.Blue());
bufferPtr[1] = TUint8(color.Green());
bufferPtr[2] = TUint8(color.Red());
bufferPtr += 3;
}
break;
case EGray4:
while (bufferPtr < bufferLimit)
{
TInt blue = bufferPtr[0];
TInt green = bufferPtr[1];
TInt red = bufferPtr[2];
TRgb color(red,green,blue);
color = TRgb::_Gray4(color._Gray4());
bufferPtr[0] = TUint8(color.Blue());
bufferPtr[1] = TUint8(color.Green());
bufferPtr[2] = TUint8(color.Red());
bufferPtr += 3;
}
break;
case EGray16:
while (bufferPtr < bufferLimit)
{
TInt blue = bufferPtr[0];
TInt green = bufferPtr[1];
TInt red = bufferPtr[2];
TRgb color(red,green,blue);
color = TRgb::_Gray16(color._Gray16());
bufferPtr[0] = TUint8(color.Blue());
bufferPtr[1] = TUint8(color.Green());
bufferPtr[2] = TUint8(color.Red());
bufferPtr += 3;
}
break;
case EGray256:
while (bufferPtr < bufferLimit)
{
TInt blue = bufferPtr[0];
TInt green = bufferPtr[1];
TInt red = bufferPtr[2];
TRgb color(red,green,blue);
color = TRgb::_Gray256(color._Gray256());
bufferPtr[0] = TUint8(color.Blue());
bufferPtr[1] = TUint8(color.Green());
bufferPtr[2] = TUint8(color.Red());
bufferPtr += 3;
}
break;
case EColor16:
while (bufferPtr < bufferLimit)
{
TInt blue = bufferPtr[0];
TInt green = bufferPtr[1];
TInt red = bufferPtr[2];
TRgb color(red,green,blue);
color = TRgb::Color16(color.Color16());
bufferPtr[0] = TUint8(color.Blue());
bufferPtr[1] = TUint8(color.Green());
bufferPtr[2] = TUint8(color.Red());
bufferPtr += 3;
}
break;
case EColor256:
while (bufferPtr < bufferLimit)
{
TInt blue = bufferPtr[0];
TInt green = bufferPtr[1];
TInt red = bufferPtr[2];
TRgb color(red,green,blue);
color = TRgb::Color256(color.Color256());
bufferPtr[0] = TUint8(color.Blue());
bufferPtr[1] = TUint8(color.Green());
bufferPtr[2] = TUint8(color.Red());
bufferPtr += 3;
}
break;
case EColor4K:
while (bufferPtr < bufferLimit)
{
TInt blue = bufferPtr[0];
TInt green = bufferPtr[1];
TInt red = bufferPtr[2];
TRgb color(red,green,blue);
color = TRgb::_Color4K(color._Color4K());
bufferPtr[0] = TUint8(color.Blue());
bufferPtr[1] = TUint8(color.Green());
bufferPtr[2] = TUint8(color.Red());
bufferPtr += 3;
}
break;
case EColor64K:
while (bufferPtr < bufferLimit)
{
TInt blue = bufferPtr[0];
TInt green = bufferPtr[1];
TInt red = bufferPtr[2];
TRgb color(red,green,blue);
color = TRgb::_Color64K(color._Color64K());
bufferPtr[0] = TUint8(color.Blue());
bufferPtr[1] = TUint8(color.Green());
bufferPtr[2] = TUint8(color.Red());
bufferPtr += 3;
}
break;
default:
break;
}
}
TInt CDrawTwentyFourBppBitmap::WriteRgbOutlineAndShadow(TInt aX, TInt aY, const TInt aLength,
TUint32 aOutlinePenColor, TUint32 aShadowColor,
TUint32 aFillColor, const TUint8* aDataBuffer)
{
DeOrientate(aX,aY);
TUint8* pixelPtr = PixelAddress(aX,aY);
const TInt pixelPtrInc = PixelAddressIncrement();
const TUint8* dataBufferPtrLimit = aDataBuffer + aLength;
TInt blendedRedColor;
TInt blendedGreenColor;
TInt blendedBlueColor;
TUint8 index = 0;
TRgb finalColor;
TRgb outlinePenColor;
outlinePenColor.SetInternal(aOutlinePenColor);
TRgb shadowColor;
shadowColor.SetInternal(aShadowColor);
TRgb fillColor;
fillColor.SetInternal(aFillColor);
const TInt redOutlinePenColor = outlinePenColor.Red();
const TInt redShadowColor = shadowColor.Red();
const TInt redFillColor = fillColor.Red();
const TInt greenOutlinePenColor = outlinePenColor.Green();
const TInt greenShadowColor = shadowColor.Green();
const TInt greenFillColor = fillColor.Green();
const TInt blueOutlinePenColor = outlinePenColor.Blue();
const TInt blueShadowColor = shadowColor.Blue();
const TInt blueFillColor = fillColor.Blue();
const TInt alpha = aOutlinePenColor >> 24;
while (aDataBuffer < dataBufferPtrLimit)
{
index = *aDataBuffer++;
if (255 == FourColorBlendLookup[index][KBackgroundColorIndex])
{
//background colour
//No drawing required so move on to next pixel.
pixelPtr += pixelPtrInc;
continue;
}
else if (255 == FourColorBlendLookup[index][KFillColorIndex])
{
//fill colour
finalColor.SetInternal(aFillColor);
}
else if (255 == FourColorBlendLookup[index][KShadowColorIndex])
{
//Shadow colour
finalColor.SetInternal(aShadowColor);
}
else if (255 == FourColorBlendLookup[index][KOutlineColorIndex])
{
//Outline colour
finalColor.SetInternal(aOutlinePenColor);
}
else
{
TRgb backgroundColor = TRgb::_Color16M(TRgb(pixelPtr[2], pixelPtr[1], pixelPtr[0])._Color16M());
blendedRedColor = (redOutlinePenColor * FourColorBlendLookup[index][KOutlineColorIndex] +
redShadowColor * FourColorBlendLookup[index][KShadowColorIndex] +
redFillColor * FourColorBlendLookup[index][KFillColorIndex] +
backgroundColor.Red() * FourColorBlendLookup[index][KBackgroundColorIndex]) >> 8;
blendedGreenColor = (greenOutlinePenColor * FourColorBlendLookup[index][KOutlineColorIndex] +
greenShadowColor * FourColorBlendLookup[index][KShadowColorIndex] +
greenFillColor * FourColorBlendLookup[index][KFillColorIndex] +
backgroundColor.Green() * FourColorBlendLookup[index][KBackgroundColorIndex]) >> 8;
blendedBlueColor = (blueOutlinePenColor * FourColorBlendLookup[index][KOutlineColorIndex] +
blueShadowColor * FourColorBlendLookup[index][KShadowColorIndex] +
blueFillColor * FourColorBlendLookup[index][KFillColorIndex] +
backgroundColor.Blue() * FourColorBlendLookup[index][KBackgroundColorIndex]) >> 8;
if (alpha != 0xff)
{
TRgb alphablend = AlphaBlend(blendedRedColor, blendedGreenColor, blendedBlueColor, TRgb(pixelPtr[2], pixelPtr[1], pixelPtr[0]), alpha);
pixelPtr[0] = TUint8(alphablend.Blue());
pixelPtr[1] = TUint8(alphablend.Green());
pixelPtr[2] = TUint8(alphablend.Red());
}
else
{
//opaque
pixelPtr[0] = TUint8(blendedBlueColor);
pixelPtr[1] = TUint8(blendedGreenColor);
pixelPtr[2] = TUint8(blendedRedColor);
}
pixelPtr += pixelPtrInc;
continue;
}
if (alpha != 0xff)
{
TRgb alphablend = AlphaBlend(finalColor, TRgb(pixelPtr[2], pixelPtr[1], pixelPtr[0]), alpha);
pixelPtr[0] = TUint8(alphablend.Blue());
pixelPtr[1] = TUint8(alphablend.Green());
pixelPtr[2] = TUint8(alphablend.Red());
}
else
{
pixelPtr[0] = TUint8(finalColor.Blue());
pixelPtr[1] = TUint8(finalColor.Green());
pixelPtr[2] = TUint8(finalColor.Red());
}
pixelPtr += pixelPtrInc;
}
return KErrNone;
}
void CDrawTwentyFourBppBitmap::BlendRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)
{
const TInt sourceAlpha = aColor.Alpha();
if (sourceAlpha == 0xFF) //Fully opaque
{
WriteRgbMulti(aX,aY,aLength,aHeight,aColor);
return;
}
else if (sourceAlpha == 0x00) //Fully transparent
{
return;
}
else //Perform alpha blending
{
TUint8* pixelPtr = PixelAddress(aX,aY);
const TInt pixelPtrInc = PixelAddressIncrement();
TUint8* pixelPtrEnd = pixelPtr + (aLength * pixelPtrInc);
TUint8 dr;
TUint8 dg;
TUint8 db;
//Perform pre-multiplication on values from aColor
const TUint8 pmsr = (sourceAlpha * aColor.Red()) / 255;
const TUint8 pmsg = (sourceAlpha * aColor.Green()) / 255;
const TUint8 pmsb = (sourceAlpha * aColor.Blue()) / 255;
for (TInt ii = 0 ; ii <= aHeight; ii++)
{
while (pixelPtr != pixelPtrEnd)
{
dr = pixelPtr[2];
dg = pixelPtr[1];
db = pixelPtr[0];
//Target has no alpha channel so assume to be 0xFF (opaque)
pixelPtr[0] = pmsb + ((0xFF-sourceAlpha) * db)/255;
pixelPtr[1] = pmsg + ((0xFF-sourceAlpha) * dg)/255;
pixelPtr[2] = pmsr + ((0xFF-sourceAlpha) * dr)/255;
pixelPtr+=pixelPtrInc;
}
pixelPtr = PixelAddress(aX, ii+aY);
pixelPtrEnd = pixelPtr + (aLength * pixelPtrInc);
}
}
}