MCL/sf/app/jrt: comparison javauis/lcdui_akn/lcdgd/src/lcdc16ma.cpp

equal deleted inserted replaced

-:f5050f1da672
+:04becd199f91
+/*
+* Copyright (c) 2005 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 <graphicsaccelerator.h>
+#include <implementationproxy.h>
+#include "lcdgdrvif.h"
+#include "lcdtransform.h"
+#include "lcdgdrvutil.h"
+#include "lcdgd.hrh"
+#include "collision.h"
+#include "lcdbitblt.h"
+#include "lcd32bpp.h"
+inline TUint32 ARGB8888ToColor16MA(TUint32 aARGB)
+{
+return aARGB;
+}
+inline TUint32 Color16MA(TInt aRed, TInt aGreen, TInt aBlue)
+{
+return TUint32((0xff<<24) | (aRed << 16) | (aGreen << 8) | aBlue);
+}
+LOCAL_C TUint32 Color16MAForward(TUint32 aRGB)
+{
+return ARGB8888ToColor16MA(aRGB);
+}
+LOCAL_C TUint32 Color16MAReverse(TUint32 aColor16MA)
+{
+return aColor16MA;
+}
+LOCAL_C TUint32 Color16MAQuantize(TUint32 aRGB)
+{
+return (aRGB & 0x00FFFFFF);     // must ensure we only return RGB.
+}
+//
+// DrawRegion support
+//
+LOCAL_C void DrawRegionColor16MAMaskToColor16MAOpaque
+(
+const TAcceleratedBitmapInfo* aDstColorBitmap,
+const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,
+const TRect&                  aDstRect,     // must be clipped to destination
+const TAcceleratedBitmapInfo* aSrcColorBitmap,
+const TAcceleratedBitmapInfo* aSrcAlphaBitmap,      // ignored
+const TLcdTransform&          aTransform        // includes anchor
+);
+LOCAL_C void DrawRegionColor16MAAlphaToColor16MAOpaque
+(
+const TAcceleratedBitmapInfo* aDstColorBitmap,
+const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,
+const TRect&                  aDstRect,     // must be clipped to destination
+const TAcceleratedBitmapInfo* aSrcColorBitmap,
+const TAcceleratedBitmapInfo* aSrcAlphaBitmap,      // ignored
+const TLcdTransform&          aTransform        // includes anchor
+);
+//
+// BitBlt support
+//
+LOCAL_C void BitBltJavaOpaqueToColor16MAOpaque
+(
+const TAcceleratedBitmapInfo*   aDstColorBitmap,
+const TAcceleratedBitmapInfo*   /*aDstAlphaBitmap*/,
+const TRect&                    aDstRect,
+const TAcceleratedBitmapInfo*   aSrcColorBitmap,
+const TAcceleratedBitmapInfo*   /*aSrcAlphaBitmap*/,
+const TLcdTransform&            aTransform
+);
+LOCAL_C void BitBltColor16MAAlphaToColor16MAMask
+(
+const TAcceleratedBitmapInfo*   aDstColorBitmap,
+const TAcceleratedBitmapInfo*   aDstAlphaBitmap,
+const TRect&                    aDstRect,
+const TAcceleratedBitmapInfo*   aSrcColorBitmap,
+const TAcceleratedBitmapInfo*   aSrcAlphaBitmap,
+const TLcdTransform&            aTransform
+);
+#ifdef RD_JAVA_NGA_ENABLED
+/**
+*
+*/
+LOCAL_C void DrawRegionColor16MAMaskToColor16MAPre
+(
+const TAcceleratedBitmapInfo* aDstColorBitmap,
+const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,
+const TRect&                  aDstRect,     // must be clipped to destination
+const TAcceleratedBitmapInfo* aSrcColorBitmap,
+const TAcceleratedBitmapInfo* aSrcAlphaBitmap,      // ignored
+const TLcdTransform&          aTransform        // includes anchor
+);
+/**
+*
+*/
+LOCAL_C void DrawRegionColor16MAAlphaToColor16MAPre
+(
+const TAcceleratedBitmapInfo* aDstColorBitmap,
+const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,
+const TRect&                  aDstRect,     // must be clipped to destination
+const TAcceleratedBitmapInfo* aSrcColorBitmap,
+const TAcceleratedBitmapInfo* aSrcAlphaBitmap,      // ignored
+const TLcdTransform&          aTransform        // includes anchor
+);
+#endif // RD_JAVA_NGA_ENABLED
+TBool DetectCollisionColor16MAColor16MA
+(
+const TAcceleratedBitmapInfo*   aBitmap1,
+const TAcceleratedBitmapInfo*   aBitmap2,
+const TRect&                    aRect1,
+const TRect&                    aRect2,
+const TLcdTransform&            aTransform1,
+const TLcdTransform&            aTransform2
+);
+TBool HasOpaquePixelColor16MA(const TAcceleratedBitmapInfo* aBitmap, const TRect& aRect);
+//
+// Image types supported by this DLL.
+//
+#define COLOR16MA_OPAQUE IMAGE_TYPE(EColor16MA, ENone, ETransparencyNone)
+#define COLOR16MA_MASK   IMAGE_TYPE(EColor16MA, ENone, ETransparencyMaskChannel)
+#define COLOR16MA_ALPHA  IMAGE_TYPE(EColor16MA, ENone, ETransparencyAlphaChannel)
+#ifdef RD_JAVA_NGA_ENABLED
+#define COLOR16MA_ALPHA_PRE  IMAGE_TYPE(EColor16MA, ENone, ETransparencyAlphaChannelPre)
+#define COLOR16MA_MASK_PRE  IMAGE_TYPE(EColor16MA, ENone, ETransparencyMaskChannelPre)
+#endif // RD_JAVA_NGA_ENABLED
+const TImageRenderer ImageRendererArray[] =
+{
+//
+// SrcOver
+//
+/*           target,          source,          transform mask,      function */
+RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_OPAQUE, KTransSimpleMask,  BitBltThirtyTwoBppSimple),
+RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_OPAQUE, KTransAllMask,   BitBltThirtyTwoBpp),
+RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_MASK,   KTransAllMask,   DrawRegionColor16MAMaskToColor16MAOpaque),
+RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_ALPHA,  KTransAllMask,   DrawRegionColor16MAAlphaToColor16MAOpaque),
+RENDER_ENTRY(COLOR16MA_OPAQUE, JAVA_OPAQUE_IMAGE, KTransAllMask,  BitBltJavaOpaqueToColor16MAOpaque),
+RENDER_ENTRY(COLOR16MA_OPAQUE, JAVA_ALPHA_IMAGE, KTransAllMask,   DrawRegionColor16MAAlphaToColor16MAOpaque),
+#ifdef RD_JAVA_NGA_ENABLED
+RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_MASK_PRE,   KTransAllMask,   DrawRegionColor16MAMaskToColor16MAPre),
+RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_ALPHA_PRE,  KTransAllMask,   DrawRegionColor16MAAlphaToColor16MAPre),
+#endif // RD_JAVA_NGA_ENABLED
+//
+// SrcCopy
+//
+/*            target,          source,              function */
+BLITTER_ENTRY(COLOR16MA_OPAQUE,  JAVA_OPAQUE_IMAGE, BitBltJavaOpaqueToColor16MAOpaque),
+SIMPLE_BLITTER_ENTRY(COLOR16MA_OPAQUE,  COLOR16MA_OPAQUE,   BitBltThirtyTwoBppSimple),
+BLITTER_ENTRY(COLOR16MA_OPAQUE,  COLOR16MA_OPAQUE,  BitBltThirtyTwoBpp),
+SIMPLE_BLITTER_ENTRY(JAVA_OPAQUE_IMAGE, COLOR16MA_OPAQUE,  BitBltThirtyTwoBppSimple),
+BLITTER_ENTRY(JAVA_OPAQUE_IMAGE, COLOR16MA_OPAQUE,  BitBltThirtyTwoBpp),
+BLITTER_ENTRY(COLOR16MA_OPAQUE,  JAVA_ALPHA_IMAGE,  BitBltJavaOpaqueToColor16MAOpaque), // entry shouldn't be needed
+BLITTER_ENTRY(JAVA_ALPHA_IMAGE,  COLOR16MA_OPAQUE,  BitBltThirtyTwoBpp),
+//
+BLITTER_ENTRY(COLOR16MA_MASK,   JAVA_ALPHA_IMAGE,   BitBltColor16MAAlphaToColor16MAMask),
+BLITTER_ENTRY(JAVA_ALPHA_IMAGE, COLOR16MA_MASK,     BitBltThirtyTwoBpp),        // mask(0,255)==alpha
+BLITTER_ENTRY(COLOR16MA_MASK, COLOR16MA_MASK,       BitBltThirtyTwoBpp),
+//
+BLITTER_ENTRY(COLOR16MA_ALPHA,  JAVA_ALPHA_IMAGE,   BitBltThirtyTwoBpp),
+BLITTER_ENTRY(JAVA_ALPHA_IMAGE, COLOR16MA_ALPHA,    BitBltThirtyTwoBpp)
+};
+const TInt ImageRendererCount = sizeof(ImageRendererArray)/sizeof(ImageRendererArray[0]);
+const TCollisionDetector CollisionDetectorArray[] =
+{
+COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyMaskChannelBit,     EColor16MABit,ETransparencyMaskChannelBit,  DetectCollisionColor16MAColor16MA),
+COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyAlphaChannelBit,    EColor16MABit,ETransparencyAlphaChannelBit, DetectCollisionColor16MAColor16MA),
+COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyMaskChannelBit,     EColor16MABit,ETransparencyAlphaChannelBit, DetectCollisionColor16MAColor16MA),
+COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyAlphaChannelBit,    EColor16MABit,ETransparencyMaskChannelBit,  DetectCollisionColor16MAColor16MA),
+COLLISION_DETECTOR_ENTRY(ENoneBit,ETransparencyNoneBit,                 EColor16MABit,ETransparencyMaskChannelBit,  DetectCollisionColor16MAColor16MA),
+COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyMaskChannelBit,     ENoneBit,ETransparencyNoneBit,              DetectCollisionColor16MAColor16MA),
+COLLISION_DETECTOR_ENTRY(ENoneBit,ETransparencyNoneBit,                 EColor16MABit,ETransparencyAlphaChannelBit, DetectCollisionColor16MAColor16MA),
+COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyAlphaChannelBit,    ENoneBit,ETransparencyNoneBit,              DetectCollisionColor16MAColor16MA)
+};
+const TInt CollisionDetectorCount = sizeof(CollisionDetectorArray)/sizeof(CollisionDetectorArray[0]);
+const TColorMap ColorMapArray[] =
+{
+{ EColor16MA, Color16MAForward, Color16MAReverse, Color16MAQuantize }
+};
+const TInt ColorMapCount = sizeof(ColorMapArray)/sizeof(ColorMapArray[0]);
+const TDrawFunctions DrawFunctionsArray[] =
+{
+{
+EColor16MA,
+CLcdGraphicsDevice::ECapFillTriangle,
+NULL,   // drawLine
+NULL,   // drawRect
+NULL,   // fillRect
+NULL,   // drawArc
+NULL,   // fillArc
+&FillTriangle32Bpp,
+NULL    // drawText
+}
+};
+const TInt DrawFunctionsCount = sizeof(DrawFunctionsArray)/sizeof(DrawFunctionsArray[0]);
+const TInt KVersionBuild = 0;
+_LIT(KProviderSymbianSoftwareLtd, "Symbian Software Ltd");
+LOCAL_C CLcdGraphicsDriverImpl* CreateColor16MADriverL();
+const TImplementationProxy ImplementationTable[] =
+{
+IMPLEMENTATION_PROXY_ENTRY(LCDGD_COLOR16MA_IMPLEMENTATION_UID, CreateColor16MADriverL)
+};
+/**
+* Ordinal 1
+*/
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+{
+aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+return ImplementationTable;
+}
+CLcdGraphicsDriverImpl* CreateColor16MADriverL()
+{
+CLcdGraphicsDriver::TDriverInfo driverInfo;
+driverInfo.iVersion      = TVersion(KLcdImgVersionMajor, KLcdImgVersionMinor, KVersionBuild);
+driverInfo.iProvider     = KProviderSymbianSoftwareLtd;
+driverInfo.iTransparencyCaps = CAP_1BPP_MASK_BITMAP|CAP_MATCHED_MASK_BITMAP|CAP_ALPHA_BITMAP;
+driverInfo.iARGB8888Mode = EColorARGB8888;
+driverInfo.iDisplayMode = EColor16MA;
+return new(ELeave) CLcdGraphicsDriverImpl
+(
+driverInfo,
+ImageRendererArray,
+ImageRendererCount,
+ColorMapArray,
+ColorMapCount,
+CollisionDetectorArray,
+CollisionDetectorCount,
+DrawFunctionsArray,
+DrawFunctionsCount
+);
+}
+// ***************************************************************
+// Render Functions
+// ***************************************************************
+LOCAL_C void BlitLineColor16MAMaskToColor16MAOpaque
+(
+TUint8* aDstAddress,
+TInt    aWidth,
+TUint8* aColorAddress,
+TInt    aColorPixelPitch
+)
+{
+TUint32* dst = (TUint32*)(aDstAddress);
+TUint32* end = dst + aWidth;
+TUint8* colorAddr = aColorAddress;
+while (dst < end)
+{
+TUint32 dstColor = *dst;
+TUint32 srcColor = *(TUint32*)colorAddr;
+TUint32 mask = (TUint32)(((TInt32)srcColor) >> 24); // Sign extend down.
+ASSERT(mask == 0 || mask == (TUint32)-1);
+dstColor = (dstColor & ~mask) | (srcColor & mask);
+ASSERT((dstColor >> 24) == 0xff);
+*dst++ = dstColor;
+colorAddr += aColorPixelPitch;
+}
+}
+LOCAL_C void DrawRegionColor16MAMaskToColor16MAOpaque
+(
+const TAcceleratedBitmapInfo* aDstColorBitmap,
+const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,
+const TRect&                  aDstRect,     // must be clipped to destination
+const TAcceleratedBitmapInfo* aSrcColorBitmap,
+const TAcceleratedBitmapInfo* /*aSrcAlphaBitmap*/,      // mask
+const TLcdTransform&          aTransform        // includes anchor
+)
+{
+ASSERT(aDstColorBitmap->iDisplayMode == EColor16MA);
+ASSERT(aSrcColorBitmap->iDisplayMode == EColor16MA);
+GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,
+BlitLineColor16MAMaskToColor16MAOpaque);
+}
+LOCAL_C void BlitLineColor16MAAlphaToColor16MAOpaque
+(
+TUint8* aDstAddress,
+TInt    aWidth,
+TUint8* aColorAddress,
+TInt    aColorPixelPitch
+)
+{
+TUint32* dst = (TUint32*)(aDstAddress);
+TUint32* end = dst + aWidth;
+TUint8* colorAddr = aColorAddress;
+while (dst < end)
+{
+TUint32 argb = *(TUint32*)colorAddr;
+TInt alpha = argb >> 24;
+if (alpha == 0xFF)
+{
+*dst = argb;
+}
+else
+{
+if (alpha)
+{
+//
+// alpha blend src over dst.
+//
+TUint32 drgb= *dst;
+alpha = (alpha << 8) | alpha;
+TUint32 dr = Blend32(alpha, ((argb>>16)&0xff), ((drgb>>16)&0xff));
+TUint32 dg = Blend32(alpha, ((argb>>8)&0xff), ((drgb>>8)&0xff));
+TUint32 db = Blend32(alpha, (argb&0xff), (drgb&0xff));
+ASSERT(dr < 256);
+ASSERT(dg < 256);
+ASSERT(db < 256);
+*dst = Color16MA(dr, dg, db);
+}
+}
+dst++;
+colorAddr += aColorPixelPitch;
+}
+}
+//
+// NB destination is fully opaque.
+//
+LOCAL_C void DrawRegionColor16MAAlphaToColor16MAOpaque
+(
+const TAcceleratedBitmapInfo* aDstColorBitmap,
+const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,
+const TRect&                  aDstRect,     // must be clipped to destination
+const TAcceleratedBitmapInfo* aSrcColorBitmap,
+const TAcceleratedBitmapInfo* /*aSrcAlphaBitmap*/,      // ignored
+const TLcdTransform&          aTransform        // includes anchor
+)
+{
+ASSERT(aDstColorBitmap->iDisplayMode == EColor16MA);
+ASSERT(aSrcColorBitmap->iDisplayMode == EColorARGB8888);
+GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,
+BlitLineColor16MAAlphaToColor16MAOpaque);
+}
+#ifdef RD_JAVA_NGA_ENABLED
+// ---------------------------------------------------------------------------
+// BlitLineColor16MAMaskToColor16MAPre
+// Target's color components are premultiplied
+// ---------------------------------------------------------------------------
+//
+LOCAL_C void BlitLineColor16MAMaskToColor16MAPre
+(
+TUint8* aDstAddress,
+TInt    aWidth,
+TUint8* aColorAddress,
+TInt    aColorPixelPitch
+)
+{
+TUint32* dst = (TUint32*)(aDstAddress);
+TUint32* end = dst + aWidth;
+TUint8* colorAddr = aColorAddress;
+while (dst < end)
+{
+TUint32 dstColor = *dst;
+TUint32 srcColor = *(TUint32*)colorAddr;
+TUint32 mask = (TUint32)(((TInt32)srcColor) >> 24); // Sign extend down.
+ASSERT(mask == 0 || mask == (TUint32)-1);
+if (mask)
+{
+// Note that the target is not always opaque anymore
+dstColor = srcColor;
+}
+*dst++ = dstColor;
+colorAddr += aColorPixelPitch;
+}
+}
+// ---------------------------------------------------------------------------
+// DrawRegionColor16MAMaskToColor16MAPre
+// ---------------------------------------------------------------------------
+//
+LOCAL_C void DrawRegionColor16MAMaskToColor16MAPre
+(
+const TAcceleratedBitmapInfo* aDstColorBitmap,
+const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,
+const TRect&                  aDstRect,     // must be clipped to destination
+const TAcceleratedBitmapInfo* aSrcColorBitmap,
+const TAcceleratedBitmapInfo* /*aSrcAlphaBitmap*/,      // mask
+const TLcdTransform&          aTransform        // includes anchor
+)
+{
+ASSERT(aDstColorBitmap->iDisplayMode == EColor16MA);
+ASSERT(aSrcColorBitmap->iDisplayMode == EColor16MA);
+GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,
+BlitLineColor16MAMaskToColor16MAPre);
+}
+// ---------------------------------------------------------------------------
+// BlitLineColor16MAMaskToColor16MAPre
+// Target's color components are premultiplied
+// ---------------------------------------------------------------------------
+//
+LOCAL_C void BlitLineColor16MAAlphaToColor16MAPre
+(
+TUint8* aDstAddress,
+TInt    aWidth,
+TUint8* aColorAddress,
+TInt    aColorPixelPitch
+)
+{
+TUint32* dstAddress = (TUint32*)(aDstAddress);
+TUint32* end = dstAddress + aWidth;
+TUint8* srcAddress = aColorAddress;
+while (dstAddress < end)
+{
+const TUint32 src=*(TUint32*)srcAddress;
+if (src >= 0xFF000000)
+{
+*(TUint32*)dstAddress = src;
+}
+else
+{
+const TUint32 srcAlpha = src >> 24;
+if (srcAlpha)
+{
+TUint32 destA;
+TUint32 destAG;
+TUint32 destRB;
+TUint32 destMultAlpha;
+const TUint32 dst = *(TUint32*)dstAddress;
+const TUint32 dstAlpha = dst >> 24;
+destA = dstAlpha << 16;
+destA = destA * (0x100 - srcAlpha);
+destA += srcAlpha << 24;
+destMultAlpha = 0xFF - srcAlpha;
+const TUint32 srcPixel = *(TUint32*)srcAddress;
+const TUint32 dstPixel = *(TUint32*)dstAddress;
+destAG = (dstPixel & 0xFF00FF00) >> 8;
+destAG = destAG * destMultAlpha;
+TUint32 srcAG = (srcPixel & 0xFF00FF00) >> 8;
+destAG &= 0xFF00FF00;
+TUint32 alphaPlus1 = srcAlpha + 1;
+destAG += srcAG * alphaPlus1;
+destRB = dstPixel & 0x00FF00FF;
+destRB = destRB * destMultAlpha;
+destRB &= 0xFF00FF00;
+TUint32 srcRB = (srcPixel & 0x00FF00FF);
+destRB += srcRB * alphaPlus1;
+destRB >>= 8;
+*(TUint32*)dstAddress = (destAG & 0x0000FF00) |
+(destRB & 0x00FF00FF) |
+(destA & 0xFF000000);
+}
+}
+dstAddress++;
+srcAddress += aColorPixelPitch;
+} // while( dstAddress < end )
+}
+// ---------------------------------------------------------------------------
+// DrawRegionColor16MAAlphaToColor16MAPre
+// ---------------------------------------------------------------------------
+//
+LOCAL_C void DrawRegionColor16MAAlphaToColor16MAPre
+(
+const TAcceleratedBitmapInfo* aDstColorBitmap,
+const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,
+const TRect&                  aDstRect,     // must be clipped to destination
+const TAcceleratedBitmapInfo* aSrcColorBitmap,
+const TAcceleratedBitmapInfo* /*aSrcAlphaBitmap*/,      // ignored
+const TLcdTransform&          aTransform        // includes anchor
+)
+{
+ASSERT(aDstColorBitmap->iDisplayMode == EColor16MA);
+ASSERT(aSrcColorBitmap->iDisplayMode == EColorARGB8888);
+GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,
+BlitLineColor16MAAlphaToColor16MAPre);
+}
+#endif // RD_JAVA_NGA_ENABLED
+// ***************************************************************
+// BitBlt Functions
+// ***************************************************************
+LOCAL_C void BlitLineJavaOpaqueToColor16MAOpaque
+(
+TUint8* aDstAddress,
+TInt    aWidth,
+TUint8* aColorAddress,
+TInt    aColorPixelPitch
+)
+{
+TUint32* dst = (TUint32*)(aDstAddress);
+TUint32* end = dst + aWidth;
+TUint8* colorAddr = aColorAddress;
+while (dst < end)
+{
+// Force alpha to opaque, because top bits in Java are 'don't care'.
+*dst++ = *(TUint32*)colorAddr | 0xFF000000;
+colorAddr += aColorPixelPitch;
+}
+}
+//
+// XRGB8888 to Color16MA opaque.
+//
+// We cannot guarantee that the java image has fully opaque pixels
+// so we need to ensure that the alpha component is initialized
+// in the destination image. Consider using COLOR16MU for java opaque
+// images.
+//
+LOCAL_C void BitBltJavaOpaqueToColor16MAOpaque
+(
+const TAcceleratedBitmapInfo*   aDstColorBitmap,
+const TAcceleratedBitmapInfo*   /*aDstAlphaBitmap*/,
+const TRect&                    aDstRect,
+const TAcceleratedBitmapInfo*   aSrcColorBitmap,
+const TAcceleratedBitmapInfo*   /*aSrcAlphaBitmap*/,
+const TLcdTransform&            aTransform
+)
+{
+ASSERT(aDstColorBitmap);
+ASSERT(aSrcColorBitmap);
+ASSERT(aDstColorBitmap->iAddress != NULL);
+ASSERT(aSrcColorBitmap->iAddress != NULL);
+ASSERT(aDstColorBitmap->iDisplayMode == EColorARGB8888);
+ASSERT(aSrcColorBitmap->iDisplayMode == EColor16MA);
+GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,
+BlitLineJavaOpaqueToColor16MAOpaque);
+}
+LOCAL_C void BlitLineColor16MAAlphaToColor16MAMask
+(
+TUint8* aDstAddress,
+TInt    aWidth,
+TUint8* aColorAddress,
+TInt    aColorPixelPitch
+)
+{
+TUint32* dst = (TUint32*)(aDstAddress);
+TUint32* end = dst + aWidth;
+TUint8* colorAddr = aColorAddress;
+while (dst < end)
+{
+TUint32 argb = *(TUint32*)colorAddr;
+TUint32 alpha = argb & 0xff000000;
+argb ^= alpha;
+// Anything other than full alpha is set to zero alpha
+alpha *= !(alpha + 0x01000000);
+argb |= alpha;
+*dst++ = argb;
+colorAddr += aColorPixelPitch;
+}
+}
+//
+// ARGB8888 -> Color16MA, Gray2
+//
+LOCAL_C void BitBltColor16MAAlphaToColor16MAMask
+(
+const TAcceleratedBitmapInfo*   aDstColorBitmap,
+const TAcceleratedBitmapInfo*   /*aDstAlphaBitmap*/,
+const TRect&                    aDstRect,
+const TAcceleratedBitmapInfo*   aSrcColorBitmap,
+const TAcceleratedBitmapInfo*   /*aSrcAlphaBitmap*/,
+const TLcdTransform&            aTransform
+)
+{
+ASSERT(aDstColorBitmap);
+ASSERT(aSrcColorBitmap);
+ASSERT(aDstColorBitmap->iAddress != NULL);
+ASSERT(aSrcColorBitmap->iAddress != NULL);
+ASSERT(aDstColorBitmap->iDisplayMode == EColor16MA);
+ASSERT(aSrcColorBitmap->iDisplayMode == EColor16MA);        // EColorARGB8888 on SymbianOS < 9.1
+GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,
+BlitLineColor16MAAlphaToColor16MAMask);
+}
+TBool DetectCollisionColor16MAColor16MA
+(
+const TAcceleratedBitmapInfo*   aBitmap1,
+const TAcceleratedBitmapInfo*   aBitmap2,
+const TRect&                    aRect1,
+const TRect&                    aRect2,
+const TLcdTransform&            aTransform1,
+const TLcdTransform&            aTransform2
+)
+{
+// if only one mask, just need to check if it has any opaque pixels
+if (aBitmap1 == NULL)
+{
+return ::HasOpaquePixelColor16MA(aBitmap2, aRect2);
+}
+if (aBitmap2 == NULL)
+{
+return ::HasOpaquePixelColor16MA(aBitmap1, aRect1);
+}
+ASSERT(aBitmap1->iDisplayMode == EColor16MA);
+ASSERT(aBitmap2->iDisplayMode == EColor16MA);
+TLcdTransform transform = aTransform1 * aTransform2.Inverse();
+TRect rect = aRect2;
+TInt h= rect.Height();
+TInt w = rect.Width();
+TPoint srcPoint = transform(rect.iTl);
+TInt dudx = transform.iDuDx;
+TInt dudy = transform.iDuDy;
+TInt dvdx = transform.iDvDx;
+TInt dvdy = transform.iDvDy;
+TInt u0   = srcPoint.iX;
+TInt v0   = srcPoint.iY;
+TInt u    = u0;
+TInt v    = v0;
+const TInt linePitch1   = aBitmap1->iLinePitch;
+const TInt linePitch2   = aBitmap2->iLinePitch;
+TUint8* address1        = aBitmap1->iAddress;
+TUint8* address2        = aBitmap2->iAddress;
+address2 += rect.iTl.iY*linePitch2 + rect.iTl.iX*sizeof(TUint32);
+if ((dudx == 1) && (dvdx == 0) && (dudy == 0) && (dvdy == 1))
+{
+address1 += v0*linePitch1 + u0*sizeof(TUint32);
+for (; h>0; --h)
+{
+TUint32* pixel1 = (TUint32*)address1;
+TUint32* pixel2 = (TUint32*)address2;
+TUint32* end = pixel2 + w;
+while (pixel2 < end)
+{
+TUint32 m2 = *pixel2++;
+TUint32 m1 = *pixel1++;
+if ((m2>>24) == 255 && (m1>>24) == 255)
+{
+return ETrue;
+}
+}
+address1 += linePitch1;
+address2 += linePitch2;
+}
+}
+else
+{
+for (; h>0; --h)
+{
+u=u0;
+v=v0;
+TUint32* pixel2 = (TUint32*)address2;
+TUint32* end = pixel2 + w;
+while (pixel2 < end)
+{
+TUint32 m2 = *pixel2++;
+TUint32 m1 = *(TUint32*)(address1 + v*linePitch1 + u*sizeof(TUint32));
+if ((m2>>24) == 255 && (m1>>24) == 255)
+{
+return ETrue;
+}
+u+=dudx;
+v+=dvdx;
+}
+u0+=dudy;
+v0+=dvdy;
+address2 += linePitch2;
+}
+}
+return EFalse;
+}
+TBool HasOpaquePixelColor16MA
+(
+const TAcceleratedBitmapInfo*   aBitmap,
+const TRect&                    aRect
+)
+{
+const TInt linePitch    = aBitmap->iLinePitch;
+TUint8* address         = aBitmap->iAddress;
+TInt h  = aRect.Height();
+TInt w  = aRect.Width();
+address += aRect.iTl.iY*linePitch + aRect.iTl.iX*sizeof(TUint32);
+for (; h>0; --h)
+{
+TUint32* pix = (TUint32*)address;
+TUint32* end = pix + w;
+while (pix < end)
+{
+if (((*pix) >> 24) == 255)
+{
+return ETrue;
+}
+++pix;
+}
+address += linePitch;
+}
+return EFalse;
+}

branch	RCL_3
changeset 14	04becd199f91
child 24	6c158198356e