diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/gdi/tgdi/TRGB.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicsdeviceinterface/gdi/tgdi/TRGB.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,602 @@ +// Copyright (c) 1998-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 +#include "TRGB.H" + + +CTRgb::CTRgb(CTestStep* aStep): + CTGraphicsBase(aStep) + { + INFO_PRINTF1(_L("Testing TRgb colour functions")); + } + +void CTRgb::RunTestCaseL(TInt aCurTestCase) + { + ((CTRgbStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(aCurTestCase) + { + case 1: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0001 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0001")); + TestGray2(); + break; + case 2: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0002 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0002")); + TestGray4(); + break; + case 3: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0003 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0003")); + TestGray16(); + break; + case 4: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0004 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0004")); + TestGray256(); + break; + case 5: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0005 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0005")); + TestColor16(); + break; + case 6: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0006 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0006")); + TestColor256(); + break; + case 7: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0007 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0007")); + TestColor4K(); + break; + case 8: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0008 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0008")); + TestColor64K(); + break; + case 9: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0009 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0009")); + TestColor16M(); + break; + case 10: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0010 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0010")); + TestColor16MU(); + break; + case 11: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0011 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0011")); + TestColor16MA(); + break; + case 12: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0012 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0012")); + TestColor256Util(); + break; + case 13: +/** + @SYMTestCaseID GRAPHICS-GDI-RGB-0013 +*/ + ((CTRgbStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-RGB-0013")); + TestColor16MAP(); + break; + case 14: + ((CTRgbStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTRgbStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + } + ((CTRgbStep*)iStep)->RecordTestResultL(); + } + +/** + Test Gray2 colour set + + Cycle through each Gray2 colour & compare the grayscale value used to create the colour + against the index value retrieved from the colour palette. + Cycle through a series of RGB values & compare the Gray2 TRgb value with a subset of the Gray256 colour-set. + + Expect the conversion from index value to grayscale colour value & back again produces identical value. + Expect the Gray2 rgb colour set forms a subset of the Gray256 colour rgb set +*/ +void CTRgb::TestGray2() + { + INFO_PRINTF1(_L("Gray2")); + + for (TInt index = 0; index < 2; index++) + { + TRgb color = TRgb::Gray2(index); + TEST(color.Gray2() == index); + } + + for (TUint32 value = 0; value <= 0x00ffffff; value += 31) + { + TRgb color(value); + TEST(color.Gray2() == color.Gray256() / 128); + } + } + +/** + Cycle through each Gray4 colour & compare the grayscale value used to create the colour + against the index value retrieved from the colour palette. + Cycle through a series of RGB values & compare the Gray4 TRgb colour value with a subset of the Gray256 colour-set. + + Expect conversion from index value to grayscale colour value & back again produces identical value. + Expect the Gray4 rgb colour set forms a subset of the Gray256 colour rgb set +*/ +void CTRgb::TestGray4() + { + INFO_PRINTF1(_L("Gray4")); + + for (TInt index = 0; index < 4; index++) + { + TRgb color = TRgb::Gray4(index); + TEST(color.Gray4() == index); + } + + for (TUint32 value = 0; value <= 0x00ffffff; value += 31) + { + TRgb color(value); + TEST(color.Gray4() == color.Gray256() / 64); + } + } + +/** + Cycle through each Gray16 colour & compare the grayscale value used to create the colour + against the index value retrieved from the colour palette. + Cycle through a series of RGB values & compare the Gray16 TRgb value with a subset of the Gray256 colour-set. + + Expect the conversion from index value to grayscale colour value & back again produces identical value. + Expect the Gray16 rgb colour set forms a subset of the Gray256 colour rgb set +*/ +void CTRgb::TestGray16() + { + INFO_PRINTF1(_L("Gray16")); + + for (TInt index = 0; index < 16; index++) + { + TRgb color = TRgb::Gray16(index); + TEST(color.Gray16() == index); + } + + for (TUint32 value = 0; value <= 0x00ffffff; value += 31) + { + TRgb color(value); + TEST(color.Gray16() == color.Gray256() / 16); + } + } + +/** + Cycle through each Gray256 colour & compare the grayscale value used to create the colour + against the index value retrieved from the colour palette. + Cycle through a series of RGB values & compare the Gray256 TRgb colour value with the value produced by generic algorithm + + Expect the conversion from index value to grayscale colour value & back again produces identical value. + Confirm the algorithm used to produce Gray256 colour set +*/ +void CTRgb::TestGray256() + { + INFO_PRINTF1(_L("Gray256")); + + for (TInt index = 0; index < 256; index++) + { + TRgb color = TRgb::Gray256(index); + TEST(color.Gray256() == index); + } + + for (TUint32 value = 0; value <= 0x00ffffff; value += 31) + { + TRgb color(value); + TInt algGray256 = (((value & 0xff) * 2) + (((value >> 8) & 0xff) * 5) + ((value >> 16) & 0xff)) / 8; + TEST(color.Gray256() == algGray256); + } + } + +/** + Test 16 Colour colour set + + Cycle through each Color16 colour & test the value used to create the colour + against the index value retrieved from the colour palette. + Compare the rgb value for each Color16 colour matches that returned by the DynamicPalette colour palette + + Expect the RGB colour value returned matches the 16colour palette +*/ +void CTRgb::TestColor16() + { + INFO_PRINTF1(_L("Color16")); + + for (TInt index = 0; index < 16; index++) + { + TRgb color = TRgb::Color16(index); + TEST(color.Color16() == index); + TEST(TRgb::Color16(index) == TRgb(DynamicPalette::Color16array()[index])); + } + } + +/** + Test 256 colour set + + Cycle through each Color256 colour & test the value used to create the colour + against the index value retrieved from the colour palette. + Compare the rgb value for each Color256 colour against the rgb value returned by the DynamicPalette colour palette + Cycle through each Color256 colour & confirm it matches the Netscape Colour Cube + + Expect the RGB colour returned matches the 256 colour palette +*/ +void CTRgb::TestColor256() + { + INFO_PRINTF1(_L("Color256")); + + const TInt mainValues[6] = {0x00, 0x33, 0x66, 0x99, 0xcc, 0xff }; + const TInt lowerValues[5] = {0x11, 0x22, 0x44, 0x55, 0x77 }; + const TInt upperValues[5] = {0x88, 0xaa, 0xbb, 0xdd, 0xee }; + + TInt index; + for (index = 0; index < 256; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Color256() == index); + TEST(TRgb::Color256(index) == TRgb(DynamicPalette::DefaultColor256Util()->iColorTable[index])); + } + + for (index = 0; index < 108; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == mainValues[index % 6]); + TEST(color.Green() == mainValues[(index / 6) % 6]); + TEST(color.Blue() == mainValues[(index / 36) % 6]); + } + for (; index < 113; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == color.Green()); + TEST(color.Green() == color.Blue()); + TEST(color.Blue() == lowerValues[index - 108]); + } + for (; index < 118; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == lowerValues[index - 113]); + TEST(color.Green() == 0); + TEST(color.Blue() == 0); + } + for (; index < 123; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == 0); + TEST(color.Green() == lowerValues[index - 118]); + TEST(color.Blue() == 0); + } + for (; index < 128; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == 0); + TEST(color.Green() == 0); + TEST(color.Blue() == lowerValues[index - 123]); + } + for (; index < 133; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == 0); + TEST(color.Green() == 0); + TEST(color.Blue() == upperValues[index - 128]); + } + for (; index < 138; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == 0); + TEST(color.Green() == upperValues[index - 133]); + TEST(color.Blue() == 0); + } + for (; index < 143; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == upperValues[index - 138]); + TEST(color.Green() == 0); + TEST(color.Blue() == 0); + } + for (; index < 148; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == color.Green()); + TEST(color.Green() == color.Blue()); + TEST(color.Blue() == upperValues[index - 143]); + } + for (; index < 256; index++) + { + TRgb color = TRgb::Color256(index); + TEST(color.Red() == mainValues[(index - 40) % 6]); + TEST(color.Green() == mainValues[((index - 40) / 6) % 6]); + TEST(color.Blue() == mainValues[((index - 40) / 36) % 6]); + } + } + +/** + Test 4096 colour set + + Cycle through each Color4K colour & compare the colorscale value used to create the colour + against the index value retrieved from the colour palette. + Cycle through a series of RGB values & compare the Color4K TRgb value against that produced by the algorithm + + Confirm the conversion from index value to 4096 colour value & back again produces identical value. + Confirm the algorithm used to produce 4096 colour set +*/ +void CTRgb::TestColor4K() + { + INFO_PRINTF1(_L("Color4K")); + + for (TInt index = 0; index < 4096; index++) + { + TRgb color = TRgb::Color4K(index); + TEST(color.Color4K() == index); + } + + for (TUint32 value = 0; value <= 0x00ffffff; value += 31) + { + TRgb color(value); + TInt color4K = ((value & 0xf00000) >> 20) | ((value & 0x00f000) >> 8) | ((value & 0x0000f0) << 4); + TEST(color.Color4K() == color4K); + } + } + +/** + Test 64K colour set + + Cycle through each Color64K colour & compare the TRgb value used to create the colour + against the index value retrieved from the colour palette. + Cycle through a series of RGB values & compare the Color64K TRgb value against that produced by the algorithm + + Confirm the conversion from index value to 64K colour value & back again produces identical value. + Confirm the algorithm used to produce 64K colour set +*/ +void CTRgb::TestColor64K() + { + INFO_PRINTF1(_L("Color64K")); + + for (TInt index = 0; index < 65536; index++) + { + TRgb color = TRgb::Color64K(index); + TEST(color.Color64K() == index); + } + + for (TUint32 value = 0; value <= 0x00ffffff; value += 31) + { + TRgb color(value); + TInt color64K = ((value & 0xf8) << 8) + ((value & 0xfc00) >> 5) + ((value & 0xf80000) >> 19); + TEST(color.Color64K() == color64K); + } + } + +/** + Test 16M colour set + + Cycle through each Color16M colour & compare the TRgb value used to create the colour + against the index value retrieved from the colour palette. + Cycle through a series of RGB values & compare the Color16M TRgb value against that produced by the algorithm + + Confirm the conversion from index value to 16M colour value & back again produces identical value. + Confirm the algorithm used to produce 16M colour set +*/ +void CTRgb::TestColor16M() + { + INFO_PRINTF1(_L("Color16M")); + + for (TUint32 value = 0; value <= 0x00ffffff; value += 31) + { + TRgb color(value); + TInt color16M = ((value & 0xff0000) >> 16) | (value & 0x00ff00) | ((value & 0x0000ff) << 16); + TRgb generatedColor = TRgb::Color16M(color16M); + TEST(color == generatedColor); + TEST(color.Color16M() == color16M); + } + } + +/** + Test 16MU colour set + + Cycle through each Color16MU colour & compare the TRgb value used to create the colour + against the index value retrieved from the colour palette. + Cycle through a series of RGB values & compare the Color16MU TRgb value against that produced by the algorithm + + Confirm the conversion from index value to 16MU colour value & back again produces identical value. + Confirm the algorithm used to produce 16MU colour set +*/ +void CTRgb::TestColor16MU() + { + INFO_PRINTF1(_L("Color16MU")); + + for (TUint32 value = 0; value <= 0x00ffffff; value += 31) + { + TRgb color(value); + TInt color16MU = ((value & 0xff0000) >> 16) | (value & 0x00ff00) | ((value & 0x0000ff) << 16); + TRgb generatedColor = TRgb::Color16MU(color16MU); + TEST(color == generatedColor); + TEST(color.Color16MU() == color16MU); + } + } + +/** + Test 16MA colour set + + Cycle through each Color16MA colour & compare the TRgb value used to create the colour + against the index value retrieved from the colour palette. + Cycle through a series of RGB values & compare the Color16MA TRgb value against that produced by the algorithm + + Confirm the conversion from index value to 16MA colour value & back again produces identical value. + Confirm the algorithm used to produce 16MA colour set +*/ +void CTRgb::TestColor16MA() + { + INFO_PRINTF1(_L("Color16MA")); + + for (TUint32 high = 0; high <= 0xffff; high += 51) + for (TUint32 low = 0; low <= 0xffff; low += 51) + { + TUint32 value = (high << 16) + low; // '+' operator has higher precedance than '<<' operator + TRgb color(value); + TInt color16MA = (0xff000000 - (value & 0xff000000)) | ((value & 0xff0000) >> 16) | (value & 0x00ff00) | ((value & 0x0000ff) << 16); + TRgb generatedColor = TRgb::Color16MA(color16MA); + TEST(color == generatedColor); + TEST(color.Color16MA() == color16MA); + } + } + +/** + Test TColor256Util + + Test functionality contained within TColor256Util. + + Confirm TColor256Util converts correctly between TRgb values & the corresponding index in the colour palette + +*/ +void CTRgb::TestColor256Util() + { + INFO_PRINTF1(_L("TColor256Util")); + + __UHEAP_MARK; + + TColor256Util* util = new TColor256Util; + CPalette* palette = NULL; + TRAPD(err,palette = CPalette::NewDefaultL(EColor256)); + TEST(err==KErrNone); + util->Construct(*palette); + TEST(Mem::Compare((TUint8*)util,sizeof(TColor256Util),(TUint8*)DynamicPalette::DefaultColor256Util(),sizeof(TColor256Util))==0); + + TInt index; + for (index = 0; index < 256; index++) + { + TRgb color = TRgb::Color256(index); + TEST(util->Color256(index) == color); + TEST(util->Color256(color) == index); + } + + TRgb* rgbBuffer = new TRgb[256]; + TUint8* indexBuffer = new TUint8[256]; + for (index = 0; index < 256; index++) + rgbBuffer[index] = TRgb::Color256(index); + util->Color256(indexBuffer,rgbBuffer,256); + for (index = 0; index < 256; index++) + TEST(indexBuffer[index]==index); + + delete[] rgbBuffer; + delete[] indexBuffer; + delete palette; + delete util; + + __UHEAP_MARKEND; + } + +/** + Validate the PreMultiplied value and the Non PreMultiplied value with the expected values. + @param aAlpha Alpha value of the color. + @param aValue The value of the color channel(ie. one of Red,Green or Blue). + @param aPreMulVal The PreMutiplied color value for aValue. + @param aNonPreMulValue The Non PreMutiplied value for aValue + (i.e the value received by Non PreMutiplying aPreMulVal). + +*/ +void CTRgb::ValidatePMAndNPM(TInt aAlpha, TInt aValue, TInt aPreMulVal, TInt aNonPreMulValue) + { + TInt expPreMulValue = (aValue*(aAlpha+1))/256; + TInt expNonPreMulValMin = (expPreMulValue * 255) / aAlpha; + TInt expNonPreMulValMax = expNonPreMulValMin + 1; + if (expNonPreMulValMax > 255) + { + expNonPreMulValMax = 255; + } + TEST(expPreMulValue == aPreMulVal); + TEST(expNonPreMulValMin <= aNonPreMulValue && expNonPreMulValMax >= aNonPreMulValue); + } + +/** + DEF103742 - Test the PreMultiply and Non PreMultiply conversion. + + Convert the color values into PreMultiplied color values and again back to + the Non PreMultiplied color values. + Compare the converted values with the expected values to validate the functionality. + + Confirm the PreMultiplied and Non PreMultiplied color values match with the expected values. +*/ +void CTRgb::TestColor16MAP() + { + INFO_PRINTF1(_L("Color16MAP")); + for (TInt alpha = 0; alpha < 256; alpha += 51) + { + for (TUint32 value = 0; value <= 0x00ffffff; value += 0x1f1f) + { + TRgb color(value, alpha); + TUint pmColor = color.Color16MAP(); + TRgb npmColor = TRgb::Color16MAP(pmColor); + + TInt pmAlpha = (pmColor & 0xFF000000) >> 24; + + // These really must be right! + TEST(pmAlpha == alpha); + TEST(npmColor.Alpha() == alpha); + + // These definitely ought to be right + if (alpha == 0) // Full transparency, expect black + { + TEST(pmColor == 0); + TEST(npmColor.Internal() == 0); + } + else if (alpha == 255) // Full opacity, expect roundtrip + { + TEST(pmColor == color.Internal()); + TEST(npmColor == color); + } + else + { + // Most awkward cases: semi-transparency. + TInt pmRed = (pmColor & 0x00FF0000) >> 16; + TInt pmGreen = (pmColor & 0x0000FF00) >> 8; + TInt pmBlue = pmColor & 0xFF; + ValidatePMAndNPM(alpha, color.Red(), pmRed, npmColor.Red()); + ValidatePMAndNPM(alpha, color.Green(), pmGreen, npmColor.Green()); + ValidatePMAndNPM(alpha, color.Blue(), pmBlue, npmColor.Blue()); + } + } + } + } + +//-------------- +__CONSTRUCT_STEP__(Rgb)