--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/screendriver/sbit/BMDRAW8C.CPP Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,551 @@
+// 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"
+
+const TInt KEightBppPaletteSize = 256;
+const TInt KEightBppInversePaletteSize = 4096;
+
+GLREF_D const TUint8 color256shadowlutab[256];
+
+// CDrawEightBppBitmapColor
+
+TInt CDrawEightBppBitmapColor::Construct(TSize aSize)
+ {
+ return Construct(aSize, (aSize.iWidth + 3) & ~3);
+ }
+
+TInt CDrawEightBppBitmapColor::Construct(TSize aSize, TInt aStride)
+ {
+ iDispMode = EColor256;
+ iShadowIndex = (TUint8*)color256shadowlutab;
+
+ return CDrawEightBppBitmapCommon::Construct(aSize, aStride);
+ }
+
+CDrawEightBppBitmapColor::~CDrawEightBppBitmapColor()
+ {
+ delete[] iPalette;
+ delete[] iColor4KIndex;
+ if (iShadowIndex != color256shadowlutab)
+ delete[] iShadowIndex;
+ }
+
+TInt CDrawEightBppBitmapColor::SetCustomPalette(const CPalette* aPalette)
+ {
+ if (aPalette)
+ {
+ if (!iPalette)
+ iPalette = new TRgb[KEightBppPaletteSize];
+ if (!iColor4KIndex)
+ iColor4KIndex = new TUint8[KEightBppInversePaletteSize];
+ if (iShadowIndex == color256shadowlutab)
+ iShadowIndex = new TUint8[KEightBppPaletteSize];
+
+ if (iPalette && iColor4KIndex && iShadowIndex)
+ {
+ TInt index = 0;
+ TRgb* palettePtr = iPalette;
+ const TRgb* const palettePtrLimit = iPalette + Min(aPalette->Entries(),KEightBppPaletteSize);
+
+ while (palettePtr < palettePtrLimit)
+ *palettePtr++ = aPalette->GetEntry(index++);
+
+ index = 0;
+ TUint8* inversePtr = iColor4KIndex;
+ const TUint8* const inversePtrLimit = iColor4KIndex + KEightBppInversePaletteSize;
+
+ while (inversePtr < inversePtrLimit)
+ *inversePtr++ = TUint8(aPalette->NearestIndex(TRgb::_Color4K(index++)));
+
+ index = 0;
+ TUint8* shadowPtr = iShadowIndex;
+ const TUint8* const shadowPtrLimit = iShadowIndex + KEightBppPaletteSize;
+ TRgb color;
+
+ while (shadowPtr < shadowPtrLimit)
+ {
+ color = iPalette[index++];
+ const TInt red = Max(color.Red() - 0x33,0) >> 4;
+ const TInt green = Max(color.Green() - 0x33,0) >> 4;
+ const TInt blue = Max(color.Blue() - 0x33,0) >> 4;
+ *shadowPtr++ = iColor4KIndex[(red << 8) | (green << 4) | blue];
+ }
+
+ return KErrNone;
+ }
+
+ // Fall through to cleanup
+ }
+
+ delete[] iPalette;
+ iPalette = NULL;
+ delete[] iColor4KIndex;
+ iColor4KIndex = NULL;
+ if (iShadowIndex != color256shadowlutab)
+ {
+ delete[] iShadowIndex;
+ iShadowIndex = (TUint8*)color256shadowlutab;
+ }
+
+ return aPalette ? KErrNoMemory : KErrNone;
+ }
+
+TInt CDrawEightBppBitmapColor::GetCustomPalette(CPalette*& aPalette)
+ {
+ TRAPD(err, aPalette = CPalette::NewDefaultL(EColor256));
+
+ if (err == KErrNone && iPalette)
+ {
+ for (TInt index = 0; index < KEightBppPaletteSize; index++)
+ aPalette->SetEntry(index, iPalette[index]);
+ }
+
+ return err;
+ }
+
+TUint8 CDrawEightBppBitmapColor::ColorToIndex(TRgb aColor) const
+ {
+ if (iColor4KIndex)
+ return iColor4KIndex[aColor._Color4K()];
+
+ return TUint8(aColor.Color256());
+ }
+
+TRgb CDrawEightBppBitmapColor::IndexToColor(TInt aIndex) const
+ {
+ if (iPalette)
+ return iPalette[aIndex];
+
+ return TRgb::Color256(aIndex);
+ }
+
+void CDrawEightBppBitmapColor::Shadow(TRgb& aColor)
+ {
+ if (iShadowMode & EFade)
+ aColor = FadeRgb(IndexToColor(ColorToIndex(aColor)));
+
+ if (iShadowMode & EShadow)
+ aColor = IndexToColor(iShadowIndex[ColorToIndex(aColor)]);
+ }
+
+//aX, aY - physical coordinates
+TRgb CDrawEightBppBitmapColor::ReadRgbNormal(TInt aX,TInt aY) const
+ {
+ return IndexToColor(*PixelAddress(aX,aY));
+ }
+
+//aRect - logical coordinates
+void CDrawEightBppBitmapColor::ShadowArea(const TRect& aRect)
+ {
+ const TRect rect(DeOrientate(aRect));//rect - physical coordinates
+
+ __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));
+
+ const TInt longWidth = iLongWidth;
+ TUint8* pixelPtr = PixelAddress(rect.iTl.iX,rect.iTl.iY);
+ const TUint8* pixelRowPtrLimit = pixelPtr + (rect.Height() * longWidth);
+ TRgb color;
+ register const TUint8* bitsEnd =
+ reinterpret_cast <const TUint8*> (iBits) + iLongWidth * iSize.iHeight;
+
+ if(pixelRowPtrLimit >= bitsEnd)
+ {
+ pixelRowPtrLimit = bitsEnd;
+ }
+
+ if (iShadowMode & EFade)
+ {
+ TUint8* pixelRowPtr = pixelPtr;
+ TUint8* pixelPtrLimit = pixelPtr + rect.Width();
+
+ while (pixelRowPtr < pixelRowPtrLimit)
+ {
+ TUint8* tempPixelPtr = pixelRowPtr;
+
+ while (tempPixelPtr < pixelPtrLimit)
+ {
+ color = IndexToColor(*tempPixelPtr);
+ color = FadeRgb(color);
+ *tempPixelPtr++ = ColorToIndex(color);
+ }
+
+ pixelRowPtr += longWidth;
+ pixelPtrLimit += longWidth;
+ }
+ }
+
+ if (iShadowMode & EShadow)
+ {
+ TUint8* pixelRowPtr = pixelPtr;
+ TUint8* pixelPtrLimit = pixelPtr + rect.Width();
+
+ while (pixelRowPtr < pixelRowPtrLimit)
+ {
+ TUint8* tempPixelPtr = pixelRowPtr;
+
+ while (tempPixelPtr < pixelPtrLimit)
+ {
+ *tempPixelPtr = iShadowIndex[*tempPixelPtr];
+ ++tempPixelPtr;
+ }
+
+ pixelRowPtr += longWidth;
+ pixelPtrLimit += longWidth;
+ }
+ }
+ }
+
+void CDrawEightBppBitmapColor::ShadowBuffer(TInt aLength,TUint32* aBuffer)
+ {
+ __ASSERT_DEBUG(aLength>0,Panic(EScreenDriverPanicInvalidParameter));
+ __ASSERT_DEBUG(aBuffer!=NULL,Panic(EScreenDriverPanicInvalidParameter));
+
+ const TUint8* limit = ((TUint8*)aBuffer) + aLength;
+
+ if (iShadowMode & EFade)
+ {
+ TUint8* buffer = (TUint8*)aBuffer;
+ TRgb color;
+
+ while (buffer < limit)
+ {
+ color = FadeRgb(IndexToColor(*buffer));
+ *buffer++ = ColorToIndex(color);
+ }
+ }
+
+ if (iShadowMode & EShadow)
+ {
+ TUint8* buffer = (TUint8*)aBuffer;
+
+ while (buffer < limit)
+ {
+ *buffer = iShadowIndex[*buffer];
+ ++buffer;
+ }
+ }
+ }
+
+//aX, aY - physical coordinates
+void CDrawEightBppBitmapColor::WriteRgb(TInt aX,TInt aY,TRgb aColor)
+ {
+ CDrawEightBppBitmapCommon::WriteRgb(aX,aY,ColorToIndex(aColor));
+ }
+
+//aX, aY - physical coordinates
+void CDrawEightBppBitmapColor::WriteBinary(TInt aX,TInt aY,TUint32* aData,TInt aLength,TInt aHeight,TRgb aColor)
+ {
+ CDrawEightBppBitmapCommon::WriteBinary(aX,aY,aData,aLength,aHeight,ColorToIndex(aColor));
+ }
+
+//aX, aY - physical coordinates
+void CDrawEightBppBitmapColor::WriteBinaryOp(TInt aX,TInt aY,TUint32* aData,TInt aLength,TInt aHeight,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode)
+ {
+ CDrawEightBppBitmapCommon::WriteBinaryOp(aX,aY,aData,aLength,aHeight,ColorToIndex(aColor),aDrawMode);
+ }
+
+//aX, aY - physical coordinates
+void CDrawEightBppBitmapColor::WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aData,TInt aLength,TRgb aColor,TBool aUp)
+ {
+ CDrawEightBppBitmapCommon::WriteBinaryLineVertical(aX,aY,aData,aLength,ColorToIndex(aColor),aUp);
+ }
+
+/**
+MAlphaBlend::WriteRgbAlphaLine() implementation.
+@see MAlphaBlend::WriteRgbAlphaLine()
+*/
+void CDrawEightBppBitmapColor::WriteRgbAlphaLine(TInt aX, TInt aY, TInt aLength,
+ const TUint8* aRgbBuffer,
+ const TUint8* aMaskBuffer,
+ MAlphaBlend::TShadowing aShadowing,
+ CGraphicsContext::TDrawMode /*aDrawMode*/)
+ {
+ DeOrientate(aX,aY);//aX, aY - physical coordinates
+ TUint8* pixelPtr = PixelAddress(aX,aY);
+ register TInt pixelPtrInc = LogicalPixelAddressIncrement();
+ const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;
+ TRgb pixelColor;
+
+ if(iScalingOff)
+ {
+ while (aMaskBuffer < maskBufferPtrLimit)
+ {
+ TRgb srcColor(aRgbBuffer[2],aRgbBuffer[1],aRgbBuffer[0]);
+ if(aShadowing == MAlphaBlend::EShdwBefore)
+ {
+ Shadow(srcColor);
+ }
+ pixelColor = ::AlphaBlend(srcColor,IndexToColor(pixelPtr[0]),aMaskBuffer[0]);
+ if(aShadowing == MAlphaBlend::EShdwAfter)
+ {
+ Shadow(pixelColor);
+ }
+ MapColorToUserDisplayMode(pixelColor);
+ pixelPtr[0] = ColorToIndex(pixelColor);
+ pixelPtr += pixelPtrInc;
+ aRgbBuffer += 4;
+ aMaskBuffer++;
+ }
+ }
+ else
+ {
+ const TUint8* bitsStart = reinterpret_cast <const TUint8*> (iBits);
+ const TUint8* bitsEnd = bitsStart + iLongWidth * iSize.iHeight;
+ while (aMaskBuffer < maskBufferPtrLimit)
+ {
+ TRgb srcColor(aRgbBuffer[2],aRgbBuffer[1],aRgbBuffer[0]);
+ if(aShadowing == MAlphaBlend::EShdwBefore)
+ {
+ Shadow(srcColor);
+ }
+ pixelColor = ::AlphaBlend(srcColor,IndexToColor(pixelPtr[0]),aMaskBuffer[0]);
+ if(aShadowing == MAlphaBlend::EShdwAfter)
+ {
+ Shadow(pixelColor);
+ }
+ MapColorToUserDisplayMode(pixelColor);
+ const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;
+ SetPixels(pixelPtr, ColorToIndex(pixelColor), pixelRowPtrLimit, bitsStart, bitsEnd);
+ pixelPtr += pixelPtrInc;
+ aRgbBuffer += 4;
+ aMaskBuffer++;
+ IncScaledY(aY);
+ }
+ }
+ }
+
+void CDrawEightBppBitmapColor::WriteRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aRows,TRgb aColor)
+ {
+ CDrawEightBppBitmapCommon::WriteRgbMulti(aX,aY,aLength,aRows,ColorToIndex(aColor));
+ }
+
+void CDrawEightBppBitmapColor::WriteRgbMultiXOR(TInt aX,TInt aY,TInt aLength,TInt aRows,TRgb aColor)
+ {
+ CDrawEightBppBitmapCommon::WriteRgbMultiXOR(aX,aY,aLength,aRows,ColorToIndex(aColor));
+ }
+
+void CDrawEightBppBitmapColor::WriteRgbMultiAND(TInt aX,TInt aY,TInt aLength,TInt aRows,TRgb aColor)
+ {
+ CDrawEightBppBitmapCommon::WriteRgbMultiAND(aX,aY,aLength,aRows,ColorToIndex(aColor));
+ }
+
+void CDrawEightBppBitmapColor::WriteRgbMultiOR(TInt aX,TInt aY,TInt aLength,TInt aRows,TRgb aColor)
+ {
+ CDrawEightBppBitmapCommon::WriteRgbMultiOR(aX,aY,aLength,aRows,ColorToIndex(aColor));
+ }
+
+//aX, aY - not deorientated
+//aLength - not scaled
+void CDrawEightBppBitmapColor::WriteRgbAlphaMulti(TInt aX,TInt aY,TInt aLength,
+ TRgb aColor,const TUint8* aMaskBuffer)
+ {
+ DeOrientate(aX,aY);//aX, aY - scaled and deorientated
+ register TUint8* pixelPtr = PixelAddress(aX,aY);
+ register TInt pixelPtrInc = LogicalPixelAddressIncrement();
+ const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;
+
+ if (iShadowMode)
+ Shadow(aColor);
+
+ register TInt red = aColor.Red();
+ register TInt green = aColor.Green();
+ register TInt blue = aColor.Blue();
+ TRgb pixelColor;
+
+ if(iScalingOff)
+ {
+ while(aMaskBuffer < maskBufferPtrLimit)
+ {
+ pixelColor = AlphaBlend(red, green, blue, IndexToColor(pixelPtr[0]), aMaskBuffer[0]);
+ pixelPtr[0] = ColorToIndex(pixelColor);
+ pixelPtr += pixelPtrInc;
+ aMaskBuffer++;
+ }
+ }
+ else
+ {
+ const TUint8* bitsStart = reinterpret_cast <const TUint8*> (iBits);
+ const TUint8* bitsEnd = bitsStart + iLongWidth * iSize.iHeight;
+ while(aMaskBuffer < maskBufferPtrLimit)
+ {
+ pixelColor = AlphaBlend(red, green, blue, IndexToColor(pixelPtr[0]), aMaskBuffer[0]);
+ const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;
+ SetPixels(pixelPtr, ColorToIndex(pixelColor), pixelRowPtrLimit, bitsStart, bitsEnd);
+ pixelPtr += pixelPtrInc;
+ aMaskBuffer++;
+ IncScaledY(aY);
+ }
+ }
+ }
+
+
+void CDrawEightBppBitmapColor::MapColorToUserDisplayMode(TRgb& aColor)
+ {
+ switch (iUserDispMode)
+ {
+ case EGray2:
+ aColor = TRgb::_Gray2(aColor._Gray2());
+ break;
+ case EGray4:
+ aColor = TRgb::_Gray4(aColor._Gray4());
+ break;
+ case EGray16:
+ case EGray256:// EGray256 can't be done - nearest is EGray16
+ aColor = TRgb::_Gray16(aColor._Gray16());
+ break;
+ case EColor16:
+ aColor = TRgb::Color16(aColor.Color16());
+ break;
+ default:
+ break;
+ }
+ }
+
+void CDrawEightBppBitmapColor::MapBufferToUserDisplayMode(TInt aLength,TUint32* aBuffer)
+ {
+ TUint8* bufferPtr = (TUint8*)aBuffer;
+ const TUint8* bufferLimit = bufferPtr + aLength;
+ TRgb color;
+
+ switch (iUserDispMode)
+ {
+ case EGray2:
+ while (bufferPtr < bufferLimit)
+ {
+ color = IndexToColor(*bufferPtr);
+ color = TRgb::_Gray2(color._Gray2());
+ *bufferPtr++ = ColorToIndex(color);
+ }
+ break;
+ case EGray4:
+ while (bufferPtr < bufferLimit)
+ {
+ color = IndexToColor(*bufferPtr);
+ color = TRgb::_Gray4(color._Gray4());
+ *bufferPtr++ = ColorToIndex(color);
+ }
+ break;
+ case EGray16:
+ case EGray256:// EGray256 can't be done - nearest is EGray16
+ while (bufferPtr < bufferLimit)
+ {
+ color = IndexToColor(*bufferPtr);
+ color = TRgb::_Gray16(color._Gray16());
+ *bufferPtr++ = ColorToIndex(color);
+ }
+ break;
+ case EColor16:
+ while (bufferPtr < bufferLimit)
+ {
+ color = IndexToColor(*bufferPtr);
+ color = TRgb::Color16(color.Color16());
+ *bufferPtr++ = ColorToIndex(color);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+TInt CDrawEightBppBitmapColor::WriteRgbOutlineAndShadow(TInt aX, TInt aY, const TInt aLength,
+ TUint32 aOutlinePenColor, TUint32 aShadowColor,
+ TUint32 aFillColor, const TUint8* aDataBuffer)
+ {
+ //This is non-optimised since this screen mode is rarely used and is usually
+ //fast enough without optimisation.
+ DeOrientate(aX,aY);
+ TUint8* pixelPtr = PixelAddress(aX,aY);
+ const TInt pixelPtrInc = LogicalPixelAddressIncrement();
+ 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();
+
+ 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::Color256(*pixelPtr);
+
+ 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;
+
+ finalColor = TRgb(blendedRedColor, blendedGreenColor, blendedBlueColor);
+ }
+
+ *pixelPtr = TUint8(finalColor.Color256());
+ pixelPtr += pixelPtrInc;
+ }
+ return KErrNone;
+ }
+