diff -r 000000000000 -r 5d03bc08d59c fbs/fontandbitmapserver/trasterizer/test/trasterizer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fbs/fontandbitmapserver/trasterizer/test/trasterizer.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,549 @@ +// Copyright (c) 2008-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 "trasterizer.h" +#include "testutils.h" +#include "examplerasterizer.h" +#include +#include +#include +#include +#include +#include + +const TDisplayMode KDisplayModes[] = {EGray256, EColor64K, EColor16MU, EColor16MAP}; +const TInt KNumDisplayModes = sizeof(KDisplayModes)/sizeof(KDisplayModes[0]); +const TRgb KStripeColours[3] = {TRgb(255,255,0), TRgb(255,0,255), TRgb(0,255,255)}; + +CTRasterizer::CTRasterizer() + { + SetTestStepName(KTRasterizerStep); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-RASTERIZER-001 + +@SYMTestPriority + High + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10860 + REQ10861 + +@SYMTestCaseDesc + Test that the example rasterizer dll "fbsrasterizer_test.dll" has been loaded. + +@SYMTestActions + On the emulator check that the rasterizer setting is "fbsrasterizer_test.dll". + Get a pointer to the rasterizer. + +@SYMTestExpectedResults + "fbsrasterizer_test.dll" has been loaded successfully +*/ +void CTRasterizer::TestLoadRasterizerDllL() + { + INFO_PRINTF1(_L("TestLoadRasterizerDll")); +#ifdef __WINS__ + _LIT8(KTestRasterizerName, "fbsrasterizer_test.dll"); + TUint8* rasterizerSetting = NULL; + UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalStringProperty, (TAny*)"FBSRASTERIZER_DLL", &rasterizerSetting); + TESTL(rasterizerSetting != NULL); + TESTL(TPtrC8(rasterizerSetting).CompareF(KTestRasterizerName) == 0); +#endif + GetExampleRasterizerL(); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-RASTERIZER-002 + +@SYMTestPriority + High + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10860 + REQ10861 + +@SYMTestCaseDesc + Test that a scanline retrieved from the example rasterizer is what we expect. + +@SYMTestActions + Create an extended bitmap and set its extended data to three colours followed by a TUint8. + The example rasterizer interprets this data as the three colours in a tricolour flag drawn + with either horizontal or vertical stripes depending on the value of the TUint8. + Draw a scanline of the extended bitmap by calling: + - CFbsRasterizer::BeginBitmap() + - CFbsRasterizer::ScanLine() + - CFbsRasterizer::EndBitmap() + +@SYMTestExpectedResults + The scan line returned by the example rasterizer should be exactly the same as the + corresponding scanline in the test data. +*/ +void CTRasterizer::TestScanLineL() + { + TBuf<32> displayModeDes(TestUtils::DisplayModeToString(iDisplayMode)); + INFO_PRINTF2(_L("TestScanLine, display mode %S"), &displayModeDes); + + const TInt KNumBeginBitmapCalls = 5; + + // Get the example rasterizer + GetExampleRasterizerL(); + + // Test for both stripe styles, 0 for vertical stripes and 1 for horizontal stripes + for (TInt stripeStyle = 0; stripeStyle < 2; stripeStyle++) + { + if (stripeStyle == 0) + { + INFO_PRINTF1(_L("... Vertical stripes")); + } + else + { + INFO_PRINTF1(_L("... Horizontal stripes")); + } + + const TSize sizeInPixels(64,32); + CFbsBitmap* extendedBitmap = CreateExtendedBitmapLC(KStripeColours, stripeStyle, sizeInPixels); + + // Begin scanline access to the extended bitmap + CFbsRasterizer::TBitmapDesc bitmapDesc; + TInt64 bitmapId = extendedBitmap->SerialNumber(); + bitmapDesc.iSizeInPixels = sizeInPixels; + bitmapDesc.iDispMode = iDisplayMode; + bitmapDesc.iDataType = KUidExampleExtendedBitmap; + bitmapDesc.iData = extendedBitmap->DataAddress(); + bitmapDesc.iDataSize = extendedBitmap->DataSize(); + extendedBitmap->BeginDataAccess(); + // test calling BeginBitmap more than once as each additional call should just increment as reference count + for (TInt i = 0; i < KNumBeginBitmapCalls; i++) + { + iRasterizer->BeginBitmap(bitmapId, bitmapDesc, NULL); + } + + TInt scanlineLength; + TPoint startPixel; + TRgb bufferColour; + // The width or height of a stripe in the tricolour flag that the extended bitmap rasterizer draws + TInt stripeSize = (stripeStyle == 0) ? sizeInPixels.iWidth/3 : sizeInPixels.iHeight/3; + for (TInt h = 0; h < sizeInPixels.iHeight; h++) + { + // Get a full scanline from the extended bitmap using the rasterizer + startPixel = TPoint(0, h); + scanlineLength = sizeInPixels.iWidth; + const TUint8* scanline = reinterpret_cast(iRasterizer->ScanLine(bitmapId, startPixel, scanlineLength)); + TESTL(scanline != NULL); + + // Make sure each pixel in the scanline is the colour that we expect + TRgb compareColour; + + for (TInt w = 0; w < scanlineLength; w++) + { + if (((stripeStyle == 0) && (w < stripeSize)) + || ((stripeStyle == 1) && (h < stripeSize))) + { + compareColour = KStripeColours[0]; // left or top + } + else if (((stripeStyle == 0) && (w >= sizeInPixels.iWidth-stripeSize)) + || ((stripeStyle == 1) && (h >= sizeInPixels.iHeight-stripeSize))) + { + compareColour = KStripeColours[2]; // right or bottom + } + else + { + compareColour = KStripeColours[1]; // middle + } + bufferColour = ExtractRgb(scanline, w, iDisplayMode); + if (((iDisplayMode != EGray256) && (bufferColour != compareColour)) + || ((iDisplayMode == EGray256) && (bufferColour != TRgb::Gray256(compareColour.Gray256())))) + { + INFO_PRINTF3(_L("Pixel comparison failed for pixel %d,%d"), w, h); + TEST(EFalse); + } + } + } + + // End scanline access to the extended bitmap + for (TInt i = 0; i < KNumBeginBitmapCalls; i++) + { + iRasterizer->EndBitmap(bitmapId); + } + extendedBitmap->EndDataAccess(); + + // Clean up + CleanupStack::Pop(1, extendedBitmap); + } + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-RASTERIZER-003 + +@SYMTestPriority + High + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10860 + REQ10861 + +@SYMTestCaseDesc + Test that we can get scanlines from 3 extended bitmaps simultaneously using the example rasterizer. + +@SYMTestActions + Load a normal bitmap. + Create 3 extended bitmaps and set their extended data to be vertically striped colours. + Draw a scanline of each extended bitmap by calling: + - CFbsRasterizer::BeginBitmap() for each extended bitmap + - CFbsRasterizer::ScanLine() for each extended bitmap + - CFbsRasterizer::EndBitmap() for each extended bitmap + Compare the first pixel of each scanline and the last pixel of each scanline against the + expected colour. + +@SYMTestExpectedResults + The rasterizer should be able to handle rasterizing up to 3 extended bitmaps at once, + all three scanlines should be returned with no errors. + The colours compared should match exactly. +*/ +void CTRasterizer::TestMultipleScanLinesL() + { + TBuf<32> displayModeDes(TestUtils::DisplayModeToString(iDisplayMode)); + INFO_PRINTF2(_L("TestMultipleScanLines, vertical stripes, display mode %S"), &displayModeDes); + + const TInt KNumBitmaps = 3; + const TInt KBaseSize = 10; + RArray bitmaps; + CleanupClosePushL(bitmaps); + + // Get the example rasterizer + GetExampleRasterizerL(); + + // Create the three differently sized extended bitmaps each coloured with vertical stripes + for (TInt i = 0; i < KNumBitmaps; i++) + { + const TSize KSizeInPixels = TSize(KBaseSize*(i+1), KBaseSize*(i+1)); + CFbsBitmap* extendedBitmap = CreateExtendedBitmapLC(KStripeColours, EFalse, KSizeInPixels); + bitmaps.AppendL(extendedBitmap); + } + + // Begin scanline access to the extended bitmaps + for (TInt i = 0; i < KNumBitmaps; i++) + { + bitmaps[i]->BeginDataAccess(); + + CFbsRasterizer::TBitmapDesc bitmapDesc; + TInt64 bitmapId = bitmaps[i]->SerialNumber(); + bitmapDesc.iSizeInPixels = bitmaps[i]->SizeInPixels(); + bitmapDesc.iDispMode = iDisplayMode; + bitmapDesc.iDataType = KUidExampleExtendedBitmap; + bitmapDesc.iData = bitmaps[i]->DataAddress(); + bitmapDesc.iDataSize = bitmaps[i]->DataSize(); + iRasterizer->BeginBitmap(bitmapId, bitmapDesc, NULL); + } + + // Get scanlines from each extended bitmap and check that the first and last pixel in each is the correct colour + for (TInt h = 0; h < KBaseSize; h++) + { + for (TInt i = 0; i < KNumBitmaps; i++) + { + const TUint8* scanline = reinterpret_cast(iRasterizer->ScanLine(bitmaps[i]->SerialNumber(), TPoint(0,h), KBaseSize*(i+1))); + TESTL(scanline != NULL); + + // Test that the first pixel is the correct colour (the first pixel in each scanline should be KStripeColours[0] + // as the bitmaps should have all been drawn with vertical stripes with the first stripe being KStripeColours[0] + TRgb bufferColour = ExtractRgb(scanline, 0, iDisplayMode); + if (((iDisplayMode != EGray256) && (bufferColour != KStripeColours[0])) + || ((iDisplayMode == EGray256) && (bufferColour != TRgb::Gray256(KStripeColours[0].Gray256())))) + { + INFO_PRINTF3(_L("Pixel comparison failed for bitmap %d, pixel 0,%d"), i, h); + TEST(EFalse); + } + // The last pixel should be KStripeColours[2] + bufferColour = ExtractRgb(scanline, (KBaseSize*(i+1))-1, iDisplayMode); + if (((iDisplayMode != EGray256) && (bufferColour != KStripeColours[2])) + || ((iDisplayMode == EGray256) && (bufferColour != TRgb::Gray256(KStripeColours[2].Gray256())))) + { + INFO_PRINTF4(_L("Pixel comparison failed for bitmap %d, pixel %d,%d"), i, (KBaseSize*(i+1))-1, h); + TEST(EFalse); + } + } + } + + // Unregister each extended bitmap + for (TInt i = 0; i < KNumBitmaps; i++) + { + iRasterizer->EndBitmap(bitmaps[i]->SerialNumber()); + bitmaps[i]->EndDataAccess(); + } + + // Cleanup + CleanupStack::PopAndDestroy(KNumBitmaps+1); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-RASTERIZER-004 + +@SYMTestPriority + High + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10860 + REQ10861 + +@SYMTestCaseDesc + Test that the rasterizer returns portions of scanline correctly + when a region of interest is specified. + +@SYMTestActions + Create an extended bitmap. + Rasterize it specifying a region of interest that has three regions that roughly + form a squared off C shape. + +@SYMTestExpectedResults + Check that scanlines returned are correct in the specified region of interest. + (Anything outside the region of interest does not matter). +*/ +void CTRasterizer::TestRegionOfInterestL() + { + TBuf<32> displayModeDes(TestUtils::DisplayModeToString(iDisplayMode)); + INFO_PRINTF2(_L("TestRegionOfInterest, horizontal stripes, display mode %S"), &displayModeDes); + + // Get the example rasterizer + GetExampleRasterizerL(); + + // Create an extended bitmap with horizontal stripes + const TSize sizeInPixels(24,24); + CFbsBitmap* extendedBitmap = CreateExtendedBitmapLC(KStripeColours, ETrue, sizeInPixels); + + // Create a region of interest in the shape of a square with a hole in the middle + TRegionFix<4> regionOfInterest; + const TInt KStripeSize = sizeInPixels.iHeight/3; + const TInt KEdgeOffset = 2; + regionOfInterest.AddRect(TRect(TPoint(KEdgeOffset,KEdgeOffset), TSize(sizeInPixels.iWidth-(KEdgeOffset*2),KStripeSize))); // top of the square + regionOfInterest.AddRect(TRect(TPoint(KEdgeOffset,sizeInPixels.iHeight-KEdgeOffset-KStripeSize), TSize(sizeInPixels.iWidth-(KEdgeOffset*2),KStripeSize))); // bottom of the square + regionOfInterest.AddRect(TRect(TPoint(KEdgeOffset,KEdgeOffset+KStripeSize), TSize(KStripeSize,sizeInPixels.iHeight-(KEdgeOffset*2)-(KStripeSize*2)))); // left of the square + regionOfInterest.AddRect(TRect(TPoint(sizeInPixels.iWidth-KEdgeOffset-KStripeSize,KEdgeOffset+KStripeSize), TSize(KStripeSize,sizeInPixels.iHeight-(KEdgeOffset*2)-(KStripeSize*2)))); // right of the square + TEST(regionOfInterest.CheckError() == EFalse); + + // Begin scanline access to the extended bitmap + CFbsRasterizer::TBitmapDesc bitmapDesc; + TInt64 bitmapId = extendedBitmap->SerialNumber(); + bitmapDesc.iSizeInPixels = sizeInPixels; + bitmapDesc.iDispMode = iDisplayMode; + bitmapDesc.iDataType = KUidExampleExtendedBitmap; + bitmapDesc.iData = extendedBitmap->DataAddress(); + bitmapDesc.iDataSize = extendedBitmap->DataSize(); + extendedBitmap->BeginDataAccess(); + iRasterizer->BeginBitmap(bitmapId, bitmapDesc, ®ionOfInterest); + + TInt scanlineLength; + TPoint startPixel; + TRgb bufferColour; + + for (TInt h = 0; h < sizeInPixels.iHeight; h++) + { + // Get scanlines from the extended bitmap using the rasterizer + startPixel = TPoint(0, h); + scanlineLength = sizeInPixels.iWidth; + const TUint8* scanline = reinterpret_cast(iRasterizer->ScanLine(bitmapId, startPixel, scanlineLength)); + TESTL(scanline != NULL); + + // Make sure each pixel in the scanline is the colour that we expect + for (TInt w = 0; w < sizeInPixels.iWidth; w++) + { + bufferColour = ExtractRgb(scanline, w, iDisplayMode); + + // Pixels that lie inside the region should be set to a flag stripe colour, pixels + // outside of the region should be white + if (regionOfInterest.Contains(TPoint(w,h))) + { + if (((iDisplayMode != EGray256) && (bufferColour != KStripeColours[h/KStripeSize])) + || ((iDisplayMode == EGray256) && (bufferColour != TRgb::Gray256(KStripeColours[h/KStripeSize].Gray256())))) + { + INFO_PRINTF3(_L("Pixel comparison failed for pixel %d,%d"), w, h); + TEST(EFalse); + } + } + else + { + if (bufferColour != KRgbWhite) + { + INFO_PRINTF3(_L("Pixel comparison failed for pixel %d,%d"), w, h); + TEST(EFalse); + } + } + } + } + + // End scanline access to the extended bitmap + iRasterizer->EndBitmap(bitmapId); + extendedBitmap->EndDataAccess(); + + // Clean up + CleanupStack::Pop(1, extendedBitmap); + } + +/** +Override of base class pure virtual +Lists the tests to be run +*/ +TVerdict CTRasterizer::doTestStepL() + { + TestLoadRasterizerDllL(); + + // Tests that require testing in multiple display modes + for (TInt i = 0; i < KNumDisplayModes; i++) + { + iDisplayMode = KDisplayModes[i]; + + TestScanLineL(); + TestMultipleScanLinesL(); + TestRegionOfInterestL(); + } + + return TestStepResult(); + } + +/** Helper function for getting a TRgb colour value from a buffer given a pixel offset and +a display mode. +@param aBuffer A buffer to extract the TRgb from +@param aPixelOffset The pixel position in the buffer to extract the TRgb from +@param aDispMode The display mode of the buffer +@return The TRgb value found at the pixel position specified + */ +TRgb CTRasterizer::ExtractRgb(const TUint8* aBuffer, TInt aPixelOffset, TDisplayMode aDispMode) + { + switch (aDispMode) + { + case EGray2: + { + TUint8 byte = *(aBuffer + (aPixelOffset >> 3)); + if (byte & (1 << (aPixelOffset & 7))) + return KRgbWhite; + return KRgbBlack; + } + case EGray4: + { + TUint8 byte = *(aBuffer + (aPixelOffset >> 2)); + byte >>= ((aPixelOffset & 3) << 1); + return TRgb::Gray4(byte & 3); + } + case EGray16: + { + TUint8 byte = *(aBuffer + (aPixelOffset >> 1)); + if (aPixelOffset & 1) + byte >>= 4; + return TRgb::Gray16(byte & 0xf); + } + case EGray256: + return TRgb::Gray256(*(aBuffer + aPixelOffset)); + case EColor16: + { + TUint8 byte = *(aBuffer + (aPixelOffset >> 1)); + if (aPixelOffset & 1) + byte >>= 4; + return TRgb::Color16(byte & 0xf); + } + case EColor256: + return TRgb::Color256(*(aBuffer + aPixelOffset)); + case EColor4K: + { + TUint16 doubleByte = *(((TUint16*)aBuffer) + aPixelOffset); + return TRgb::Color4K(doubleByte & 0xfff); + } + case EColor64K: + { + TUint16 doubleByte = *(((TUint16*)aBuffer) + aPixelOffset); + return TRgb::Color64K(doubleByte); + } + case EColor16M: + { + aBuffer += aPixelOffset * 3; + TInt value = *aBuffer++; + value |= *aBuffer++ << 8; + value |= *aBuffer << 16; + return TRgb::Color16M(value); + } + case ERgb: + return *(((TRgb*)aBuffer) + aPixelOffset); + case EColor16MU: + { + // Note this is | with 0xFF000000 to match the example rasterizer which sets + // the alpha to 0xFF when drawing using EColor16MU + return TRgb::Color16MU((*(((TUint32*)aBuffer) + aPixelOffset)) | 0xFF000000); + } + case EColor16MA: + { + return TRgb::Color16MA(*(((TUint32*)aBuffer) + aPixelOffset)); + } + case EColor16MAP: + { + return TRgb::_Color16MAP(*(((TUint32*)aBuffer) + aPixelOffset)); + } + default: + break; + }; + return KRgbBlack; + } + +/** Helper function for creating an extended bitmap. +@param aColours A pointer to an array of three colours to use when creating the extended bitmap, +these colours define the colours used when drawing the stripes in the extended bitmap. +@param aHorizontalStripe ETrue for horizontal stripes, EFalse for vertical stripes. +@param aSizeInPixels The size of the extended bitmap to create. +@return A pointer to a newly created extended bitmap that has been pushed on to the cleanup stack. + */ +CFbsBitmap* CTRasterizer::CreateExtendedBitmapLC(const TRgb* aColours, TBool aHorizontalStripe, TSize aSizeInPixels) + { + // Set up the buffer containing the three TRgb values and one TUint8 value that the rasterizer expects + TInt dataSize = (sizeof(TRgb)*3) + sizeof(TUint8); // estimate the size to be written + TUint8* data = new (ELeave)TUint8[dataSize]; + CleanupArrayDeletePushL(data); + RMemWriteStream writeStream; + writeStream.Open(data, dataSize); + CleanupClosePushL(writeStream); + writeStream << aColours[0]; + writeStream << aColours[1]; + writeStream << aColours[2]; + TUint8 stripe = aHorizontalStripe; // EFalse is vertical stripes, ETrue is horizontal stripes + writeStream << stripe; + dataSize = writeStream.Sink()->TellL(MStreamBuf::EWrite).Offset(); // get the actual size written + CleanupStack::PopAndDestroy(&writeStream); + + CFbsBitmap* extendedBitmap = new(ELeave) CFbsBitmap; + + TInt err = extendedBitmap->CreateExtendedBitmap(aSizeInPixels, + iDisplayMode, + KUidExampleExtendedBitmap, + data, + dataSize); + CleanupStack::PopAndDestroy(data); + CleanupStack::PushL(extendedBitmap); + TESTL(err == KErrNone); + + return extendedBitmap; + }