1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  NVG Decoder source file

    15 *

    16 */

    17 

    18  

    19 #include <s32mem.h>

    20 #include <libc/math.h> 

    21 #include <e32math.h>

    22 

    23 #include "nvg.h"

    24 #include "nvgfittoviewbox.h"

    25 #include "NVGUtil.h"

    26 

    27 #include "NVGCSIcon.h"

    28 #include "NVGTLVIcon.h"

    29 #include "FloatFixPt.h"

    30 

    31 #include "NVGIconData.h"

    32 

    33 /*

    34  * may be we should use dynamic_cast?

    35  */

    36 #define CSICON(icon)      ((CNVGCSIcon *)icon) 

    37 #define TLVICON(icon)     ((CNVGTLVIcon *)icon) 

    38 

    39 enum TNVGFormats

    40     {

    41     ENVGCS,

    42     ENVGTLV

    43     };

    44 

    45 /*

    46  *  NVG-CS version

    47  */

    48 //const TInt KVersion1   = 1;

    49 const TInt KVersion2   = 2;

    50 

    51 /*

    52  * constants for nvg file header offsets

    53  */ 

    54 const TUint8 KNVG_SIGNATURE[]       = "nvg";

    55 const TInt KNVG_SIGNATURE_LENGTH    = sizeof(KNVG_SIGNATURE) - sizeof('\0');

    56 const TInt KNVG_COMMANDSECTION_OFS  = 2;

    57 const TInt KNVG_VERSION_OFS         = 3;

    58 const TInt KNVG_RGBA_OFS            = 4;

    59 const TInt KNVG_HEADERSIZE_OFS      = 4;

    60 const TInt KNVG_PATHDATATYPE_OFS    = 26;

    61 const TInt KNVG_SCALE_OFS           = 28;

    62 const TInt KNVG_BIAS_OFS            = 32;

    63 const TInt KNVG_VIEWBOX_X_OFS       = 36;

    64 const TInt KNVG_VIEWBOX_Y_OFS       = 40;

    65 const TInt KNVG_VIEWBOX_WIDTH_OFS   = 44;

    66 const TInt KNVG_VIEWBOX_HEIGHT_OFS  = 48;

    67 

    68 const TInt KNVG_PAINTSECTION_LINEARGRAD_TRANSFORM_OFFSET = 20;

    69 const TInt KNVG_PAINTSECTION_RADIALGRAD_TRANSFORM_OFFSET = 24;

    70 

    71 /*

    72  * nvg-cs commands

    73  */ 

    74 const TInt KCMD_SET_FILL_PAINT           = 4  << 24;

    75 const TInt KCMD_SET_COLOR_RAMP           = 6  << 24;

    76 const TInt KCMD_DRAW_PATH                = 7  << 24;

    77 const TInt KCMD_SET_TRANSFORMATION       = 8  << 24;

    78 const TInt KCMD_SET_STROKE_PAINT         = 5  << 24;

    79 const TInt KCMD_SET_STROKE_WIDTH         = 9  << 24;

    80 const TInt KCMD_SET_STROKE_LINE_JOIN_CAP = 10 << 24;

    81 const TInt KCMD_SET_STROKE_MITER_LIMIT   = 11 << 24;

    82 

    83 /*

    84  * stroke cap style

    85  */

    86 const TInt KCAP_BUTT        = 1;

    87 const TInt KCAP_SQUARE      = 2;

    88 const TInt KCAP_ROUND       = 3;

    89 

    90 /*

    91  * stroke join style

    92  */

    93 const TInt KLINE_JOIN_BEVEL = 1;

    94 const TInt KLINE_JOIN_MITER = 2;

    95 const TInt KLINE_JOIN_ROUND = 3;

    96 

    97 /*

    98  * fill paint type

    99  */

   100 const TInt KPAINT_FLAT      = 1;

   101 const TInt KPAINT_LGRAD     = 2;

   102 const TInt KPAINT_RGRAD     = 3;

   103 

   104 /*

   105  * stroke paint type

   106  */

   107 const TInt KSTROKE_LGRAD        = 2;

   108 const TInt KSTROKE_RGRAD        = 3;

   109 const TInt KSTROKE_COLOR_RAMP   = 4;

   110 

   111 /*

   112  * nvg offset

   113  */

   114 const TInt KOffsetReserved1       = 6;

   115 

   116 /*

   117  * transform encoding values

   118  */

   119 const TInt KTRANSFORM_COMPLETE    = 0;

   120 const TInt KTRANSFORM_SCALING     = 2;

   121 const TInt KTRANSFORM_SHEARING    = 4;

   122 const TInt KTRANSFORM_ROTATION    = 8;

   123 const TInt KTRANSFORM_TRANSLATION = 16;

   124 

   125 #ifdef OPENVG_OBJECT_CACHING

   126 const VGfloat KIdentityMatrix[] = 

   127     {

   128     1.0f, 0.0f, 0.0f,

   129     0.0f, 1.0f, 0.0f,

   130     0.0f, 0.0f ,1.0f

   131     };

   132 #endif

   133 

   134 /*

   135  * function to delete array, for basic types

   136  */

   137 GLDEF_C void CleanupArray( TAny * aObj )

   138     {

   139     delete [] aObj;

   140     }

   141 

   142 /*

   143  * function to delete array of TFloatFixArray

   144  */

   145 GLDEF_C void CleanupTFloatFixArray( TAny * aObj )

   146     {

   147     TFloatFixPt * ff = (TFloatFixPt *)aObj;

   148     delete [] ff;

   149     }

   150 

   151 /**

   152  * @class   TNVGEngineInternal

   153  * This class is added to maintain BC.

   154  * If you want to add new member variable you can add in this class, without breaking BC.

   155  * It is better to add members which are depend on macro's in this class.

   156  */

   157 class TNVGEngineInternal

   158     {

   159 public:

   160     TNVGEngineInternal()

   161         {

   162 #ifdef    OPENVG_OBJECT_CACHING

   163         iCreatingNVGIcon = 0;

   164         iCurrentNVGIcon  = 0;

   165 #endif

   166         }

   167     

   168 #ifdef    OPENVG_OBJECT_CACHING

   169     TInt        iCreatingNVGIcon;

   170     MNVGIcon *  iCurrentNVGIcon;

   171 #endif

   172     };

   173 

   174 CNvgEngine::CNvgEngine()

   175     : iCurrentBufferSize(1, 1),

   176       iPath(VG_INVALID_HANDLE),

   177       iPaintFill(VG_INVALID_HANDLE),

   178       iPaintStroke( VG_INVALID_HANDLE),

   179       iUserStrokePaintColor(0xFFFFFFFF),

   180       iRotateApplied(EFalse),

   181       iLastPathDataType(0),

   182       iPreserveAspectSetting(ENvgPreserveAspectRatio_XmidYmid),

   183       iSmilFitSetting(ENvgMeet),

   184       iVGImageBinder(0)

   185     {

   186     }

   187 

   188 EXPORT_C CNvgEngine* CNvgEngine::NewL()

   189     {

   190     CNvgEngine* self    = new (ELeave) CNvgEngine;

   191     CleanupStack::PushL(self);

   192     self->ConstructL();

   193     CleanupStack::Pop(self);

   194     return self;

   195     }

   196 

   197 void CNvgEngine::ConstructL()

   198     {

   199     vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);

   200     vgSeti(VG_FILL_RULE, VG_NON_ZERO);

   201     

   202     iInternal = new (ELeave) TNVGEngineInternal;

   203     iPaintFill = vgCreatePaint();

   204     }

   205 

   206 EXPORT_C CNvgEngine::~CNvgEngine()

   207     {

   208     if (iPath != VG_INVALID_HANDLE)

   209         {

   210         vgDestroyPath(iPath);

   211         }

   212     

   213     if (iPaintFill != VG_INVALID_HANDLE)

   214         {

   215         vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);

   216         vgDestroyPaint(iPaintFill);

   217         }

   218 		

   219     if (iPaintStroke != VG_INVALID_HANDLE)

   220         {

   221         vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH);

   222         vgDestroyPaint(iPaintStroke);

   223         }

   224 

   225     

   226 #ifdef    OPENVG_OBJECT_CACHING

   227     if (iInternal)

   228         {

   229         delete iInternal->iCurrentNVGIcon;

   230         }

   231 #endif

   232     

   233     delete iInternal;

   234     }

   235 

   236 /**

   237  * @brief  Set the angle for rotation of the NVG graphic

   238  * @version

   239  * @param    aAngle counter-clockwise rotation by a given angle (expressed in degrees)

   240  *              aX, aY  point around which the rotation must take place

   241  * @return  None

   242  */

   243 EXPORT_C void CNvgEngine::Rotate(TReal32 aAngle, TReal32 aCentreX, TReal32 aCentreY) __SOFTFP

   244     {

   245     if(aAngle)

   246         {

   247         iRotateApplied  = ETrue;

   248         iCentreX        = aCentreX;

   249         iCentreY        = aCentreY;

   250         iRotateAngle    = aAngle;

   251         }

   252     else

   253         {

   254         iRotateApplied  = EFalse;

   255         iCentreX        = 0;

   256         iCentreY        = 0;

   257         iRotateAngle    = 0;

   258         }

   259     }

   260 

   261 /**

   262  * @brief  Gets the viewbox width and height from the NVG bytedata

   263  * @version

   264  * @param   aBuf NVG byte data of the file

   265  * @return  content dimension

   266  */

   267 EXPORT_C TSize CNvgEngine::ContentDimensions(const TDesC8& aBuf)

   268     {

   269     if (aBuf.Length() < KNVG_VIEWBOX_HEIGHT_OFS + sizeof (TReal32))

   270         {

   271         return TSize(0, 0);

   272         }

   273     

   274     const TUint8* lBuf = aBuf.Ptr();

   275     TReal32 lViewboxWidth = * (TReal32*)(lBuf + KNVG_VIEWBOX_WIDTH_OFS);

   276     TReal32 lViewboxHeight = * (TReal32*)(lBuf + KNVG_VIEWBOX_HEIGHT_OFS);

   277     

   278     if (lViewboxWidth > 0 && lViewboxHeight > 0)

   279         {

   280         return TSize(lViewboxWidth, lViewboxHeight);

   281         }

   282     else

   283         {

   284         return TSize(0, 0);

   285         }

   286     }

   287 

   288 TInt CNvgEngine::InitializeGC()

   289     {

   290     if (iPaintFill == VG_INVALID_HANDLE)

   291         {

   292         iPaintFill = vgCreatePaint();

   293         if (iPaintFill == VG_INVALID_HANDLE)

   294             {

   295             return OpenVGErrorToSymbianError(vgGetError());

   296             }

   297         }

   298     

   299     vgSetPaint(iPaintFill, VG_FILL_PATH);

   300     if (iPaintStroke == VG_INVALID_HANDLE)

   301         {

   302         iPaintStroke = vgCreatePaint();

   303         if (iPaintStroke == VG_INVALID_HANDLE)

   304             {

   305             return OpenVGErrorToSymbianError(vgGetError());

   306             }

   307         }

   308     

   309     vgSetPaint( iPaintStroke, VG_STROKE_PATH);

   310     

   311     return KErrNone;

   312     }

   313 

   314 EXPORT_C void CNvgEngine::ResetNvgState()

   315     {

   316     if (iPath != VG_INVALID_HANDLE)

   317         {

   318         vgDestroyPath(iPath);

   319         iPath = VG_INVALID_HANDLE;

   320         }

   321     

   322     if (iPaintFill != VG_INVALID_HANDLE)

   323         {

   324         vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);

   325         vgDestroyPaint(iPaintFill);

   326         iPaintFill = VG_INVALID_HANDLE;

   327         }

   328 		

   329     if (iPaintStroke != VG_INVALID_HANDLE)

   330         {

   331         vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH);

   332         vgDestroyPaint(iPaintStroke);

   333         iPaintStroke = VG_INVALID_HANDLE;

   334         }

   335     }

   336 

   337 EXPORT_C TInt CNvgEngine::DrawNvg(const TDesC8& aBuf, const TSize& aSize, CFbsBitmap* aDstBitmap, CFbsBitmap* aMask)

   338     {

   339     TInt error = KErrNone;

   340     

   341     /*

   342      * Get Matrix modes and all caller matrices (must be restored afterwards)

   343      */ 

   344     UpdateClientMatrices();

   345     

   346     TRAP(error, DoDrawNVGL(aBuf, aSize, aDstBitmap, aMask));

   347     

   348     /*

   349      * restore everything as we may have changed matrix mode

   350      */             

   351     RestoreClientMatrices();

   352 	vgSeti(VG_SCISSORING, VG_FALSE);

   353 

   354 	if (error)

   355 	    {

   356 	    NVG_DEBUGP2("Error in NVG rendering %d", error);

   357 	    }

   358     return error;

   359     }

   360 

   361 EXPORT_C MNVGIcon * CNvgEngine::CreateNVGIcon(const TDesC8& aBuf, const TSize& aSize)

   362     {    

   363     NVG_DEBUGP1("Creating NVGCSIcon");

   364     

   365     MNVGIcon * nvgIcon = 0;

   366 

   367     /*

   368      * this is bit unreadable,

   369      * need to find a better design to separate the object caching solution from normal rendering,

   370      * but anyway I guess its better than those ifdef's, in that code scanner won't give any warnings

   371      */

   372     COND_COM_OC_NOC(

   373     {

   374     if (iInternal->iCurrentNVGIcon)

   375         {

   376         delete iInternal->iCurrentNVGIcon;

   377         }

   378     

   379     iInternal->iCurrentNVGIcon     = 0;

   380     iInternal->iCreatingNVGIcon    = 1;

   381     

   382     if (DrawNvg(aBuf, aSize, 0, 0) != KErrNone)

   383         {

   384         delete iInternal->iCurrentNVGIcon;

   385         iInternal->iCurrentNVGIcon = 0;

   386         }

   387     

   388     iInternal->iCreatingNVGIcon    = 0;

   389     nvgIcon = iInternal->iCurrentNVGIcon;

   390     iInternal->iCurrentNVGIcon = 0;

   391     },

   392     {

   393     (void)aBuf;

   394     (void)aSize;

   395     });

   396 

   397     return nvgIcon;

   398     }

   399 

   400 void CNvgEngine::DoDrawNVGL(const TDesC8& aBuffer, const TSize& aSize, CFbsBitmap* aDstBitmap, CFbsBitmap* aMask)

   401     {

   402     TInt drawStatus = KErrNone;

   403 

   404     if (iCurrentBufferSize != aSize)

   405         { 

   406         iCurrentBufferSize = aSize;

   407         }

   408     

   409     iDstBimtap = aDstBitmap;

   410     

   411     TDereferencer nvgIconData(aBuffer);

   412 

   413     TUint8 * signature = nvgIconData.DerefInt8ArrayL(KNVG_SIGNATURE_LENGTH);

   414 

   415     // checking the 'nvg' signature

   416     if (Mem::Compare(signature, KNVG_SIGNATURE_LENGTH, KNVG_SIGNATURE, KNVG_SIGNATURE_LENGTH) != 0)

   417         {

   418         NVG_DEBUGP1("Not an NVG icon");

   419         User::Leave(KErrNotSupported);

   420         }

   421 

   422     // last two bits are for identifying the nvg type. currently nvg-cs or nvg-tlv

   423     TUint16   nvgType = nvgIconData.DerefInt16L(KOffsetReserved1) & 0x03;

   424     

   425     switch (nvgType)

   426         {

   427         case ENVGCS:

   428             {

   429             drawStatus = DrawCommandSectionL(&nvgIconData, aSize, aDstBitmap, aMask);

   430             break;

   431             }

   432         case ENVGTLV:

   433             {

   434             drawStatus = DrawTLVL(aBuffer, aSize, aDstBitmap, aMask);

   435             break;

   436             }

   437         default:

   438             drawStatus = KErrNotSupported;

   439             break;

   440         }

   441     

   442     User::LeaveIfError(drawStatus);

   443     }

   444 

   445 TInt CNvgEngine::DrawTLVL(const TDesC8& aBuf, const TSize& aTargetSize, CFbsBitmap* /*aDstBitmap*/, CFbsBitmap * /*aMask*/)

   446     {

   447     TInt ret = KErrNone;

   448     

   449     // Try to set user's matrix to path matrix

   450     VGfloat origMatrix[9];

   451     vgGetMatrix(origMatrix);

   452     

   453     vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE); 

   454     vgLoadMatrix(origMatrix);

   455     

   456 #ifndef __MIRROR_

   457     vgScale(1.0f, -1.0f);

   458     vgTranslate(0, (VGfloat)(-iCurrentBufferSize.iHeight));

   459 #endif

   460 

   461     /*

   462      * this is bit unreadable,

   463      * need to find a better design to separate the object caching solution from normal rendering,

   464      * but anyway I guess its better than those ifdef's, in that code scanner won't give any warnings

   465      */

   466     COND_COM_OC_NOC(

   467     {

   468     if (iInternal->iCreatingNVGIcon)

   469         {

   470         iInternal->iCurrentNVGIcon = CNVGTLVIcon::NewL();

   471         TLVICON(iInternal->iCurrentNVGIcon)->SetVGImageBinder(iVGImageBinder);

   472         TLVICON(iInternal->iCurrentNVGIcon)->CreateL(aBuf, aTargetSize);

   473         }

   474     else

   475         {

   476         CNVGTLVIcon * tlvIcon = CNVGTLVIcon::NewL();

   477         CleanupStack::PushL(tlvIcon);

   478         tlvIcon->SetVGImageBinder(iVGImageBinder);

   479         tlvIcon->DirectDrawL(aBuf, aTargetSize);

   480         CleanupStack::PopAndDestroy(tlvIcon);        

   481         }

   482 

   483     },

   484     {

   485     CNVGTLVIcon * tlvIcon = CNVGTLVIcon::NewL();

   486     CleanupStack::PushL(tlvIcon);

   487     TLVICON(tlvIcon)->SetVGImageBinder(iVGImageBinder);

   488     TLVICON(tlvIcon)->DirectDrawL(aBuf, aTargetSize);

   489     CleanupStack::PopAndDestroy(tlvIcon);                    

   490     });

   491     

   492     vgSeti(VG_SCISSORING, VG_FALSE);

   493     

   494     return ret;

   495     }

   496 

   497 TInt CNvgEngine::CreatePathHandle(TInt16 aPathDataType, TReal32 aScale, TReal32 aBias)

   498     {

   499     (void) aScale;

   500     (void) aBias;

   501     

   502     TInt error = KErrNone;

   503     

   504     if (iLastPathDataType != aPathDataType)

   505         {

   506         if (iPath != VG_INVALID_HANDLE)

   507             {

   508             vgDestroyPath(iPath);

   509             iPath = VG_INVALID_HANDLE;

   510             }

   511         }

   512     

   513     if (iPath == VG_INVALID_HANDLE)

   514         {

   515         switch (aPathDataType)

   516             {

   517             case EEightBitEncoding:

   518                 {

   519                 iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,

   520                 VG_PATH_DATATYPE_S_16, 1.0f/2.0f, 0.0f, 0, 0,

   521                 VG_PATH_CAPABILITY_APPEND_TO);            

   522                 }

   523                 break;

   524                        

   525             case ESixteenBitEncoding:

   526                 {

   527                 iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,

   528                 VG_PATH_DATATYPE_S_16, 1.0f/16.0f, 0.0f, 0, 0,

   529                 VG_PATH_CAPABILITY_APPEND_TO);            

   530                 }

   531                 break;

   532                        

   533             case EThirtyTwoBitEncoding:

   534                 {

   535                 iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,

   536                 VG_PATH_DATATYPE_S_32, 1.0f/65536.0f, 0.0f, 0, 0,

   537                 VG_PATH_CAPABILITY_APPEND_TO);            

   538                 }

   539                 break;

   540                        

   541             default:

   542                 {   

   543                 return KErrCorrupt;

   544                 }

   545             }

   546         }

   547     

   548     if( iPath == VG_INVALID_HANDLE )

   549         {

   550         // get the symbian error code

   551         error = OpenVGErrorToSymbianError(vgGetError());

   552         

   553         if (error == KErrNoMemory)

   554             {

   555             NVG_DEBUGP1("NVG Error OOM");

   556             ResetNvgState();

   557             }

   558         return error;

   559         }

   560     

   561     iLastPathDataType   = aPathDataType;

   562 

   563     return error;

   564     }

   565 

   566 TInt CNvgEngine::DrawCommandSectionL(TDereferencer * aIconData, const TSize& aTargetSize, CFbsBitmap * /*aDstBitmap*/, CFbsBitmap * /*aMask*/)

   567     {

   568     TInt16 lHeaderSize  = aIconData->DerefInt16L(KNVG_HEADERSIZE_OFS);

   569     TInt8 NVGVersion    = aIconData->DerefInt8L(KNVG_VERSION_OFS);

   570     

   571     User::LeaveIfError(InitializeGC());

   572 

   573     TInt16 lPathDataType = aIconData->DerefInt16L(KNVG_PATHDATATYPE_OFS);

   574     TReal32 lScale       = aIconData->DerefReal32L(KNVG_SCALE_OFS);

   575     TReal32 lBias        = aIconData->DerefReal32L(KNVG_BIAS_OFS);

   576 

   577     User::LeaveIfError(CreatePathHandle(lPathDataType, lScale, lBias));

   578     

   579     vgSetPaint(iPaintFill, VG_FILL_PATH);

   580     

   581     COND_COM_OC_OOC(

   582     if (iInternal->iCreatingNVGIcon)

   583         {

   584         iInternal->iCurrentNVGIcon = CNVGCSIcon::NewL(aIconData->GetPtr());

   585         });

   586     

   587     VGfloat lCurrentPathMatrix[9];

   588     vgGetMatrix(lCurrentPathMatrix);

   589     

   590     vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);  

   591     

   592     /*

   593      * We use the caller's base batrix regardless of which mode the caller was.

   594      * The caller may have set the matrix in VG_MATRIX_IMAGE_USER_TO_SURFACE mode

   595      * as it thinks it is drawing images (textures).

   596      * But even though the texture gets stroked instead, we must use the caller's

   597      * transformation matrix.

   598      * Everything gets restored to the original values before we return.

   599      */

   600     vgLoadMatrix(lCurrentPathMatrix);

   601     

   602     ApplyScissoring(lCurrentPathMatrix, aTargetSize);

   603 

   604     /*

   605      * set the rotation angle if available

   606      */

   607     if (iRotateApplied)

   608         {           

   609         ApplyRotation();

   610         }

   611     

   612 #ifdef __MIRROR_    

   613     vgScale(1.0f, -1.0f);

   614     vgTranslate(0, (VGfloat)(-iCurrentBufferSize.iHeight) );

   615 #endif

   616         

   617     TReal32 lViewboxX   = aIconData->DerefReal32L(KNVG_VIEWBOX_X_OFS);

   618     TReal32 lViewboxY   = aIconData->DerefReal32L(KNVG_VIEWBOX_Y_OFS);

   619     TReal32 lViewboxW   = aIconData->DerefReal32L(KNVG_VIEWBOX_WIDTH_OFS);

   620     TReal32 lViewboxH   = aIconData->DerefReal32L(KNVG_VIEWBOX_HEIGHT_OFS);

   621      

   622     ApplyViewboxToViewPortTransformationL(aTargetSize, lViewboxX, lViewboxY, lViewboxW, lViewboxH);

   623     

   624     TPtr8 ptr = aIconData->GetPtr();

   625     

   626     TInt offsetSectionLength = aIconData->GetLength() - lHeaderSize;

   627     TUint8 * offsetPtr = aIconData->DerefInt8ArrayL(offsetSectionLength, lHeaderSize);

   628     

   629     TDereferencer offsetSection(offsetPtr, offsetSectionLength);

   630 

   631     TUint16 lOffsetVectorCount  = offsetSection.DerefInt16L();

   632 

   633     offsetPtr = aIconData->DerefInt8ArrayL(offsetSectionLength - sizeof(TUint16), lHeaderSize + sizeof(TUint16));

   634     TDereferencer offsetVector(offsetPtr, offsetSectionLength - sizeof(TUint16));

   635 

   636     idoFill     = VG_FALSE;

   637     idoStroke   = VG_FALSE;

   638     

   639     TPtr8 offsetTPtr = offsetVector.GetPtr();

   640     

   641     TInt commandSectionOffset = lOffsetVectorCount * sizeof(TUint16);

   642     TDereferencer commandSection((unsigned char*)(offsetTPtr.Ptr() + commandSectionOffset), 

   643             aIconData->GetLength() - commandSectionOffset - lHeaderSize - sizeof(TUint16));

   644 

   645     // from version 2 onwards command section will start on word boundary

   646     if (NVGVersion >= KVersion2 && ((lOffsetVectorCount  & 0x01) == 0))

   647         {

   648         commandSection.SkipL(2);

   649         }

   650     

   651     TUint16 lCmdCount = commandSection.DerefInt16L();

   652     

   653     commandSection.SkipL(KNVG_COMMANDSECTION_OFS);

   654 

   655     /*

   656      * from version 2 onwards there will be a padding added

   657      * after the command count to make it word aligned

   658      */

   659     if (NVGVersion >= KVersion2)

   660         {

   661         commandSection.SkipL(2);

   662         }

   663 

   664     ExecuteNVGCSCommandLoopL(lCmdCount, aIconData, &offsetVector, &commandSection, NVGVersion);

   665     

   666     return KErrNone;

   667     }

   668 

   669 void CNvgEngine::ApplyRotation()

   670     {

   671     vgTranslate(iCentreX, iCentreY);  

   672     vgRotate(iRotateAngle);

   673     vgTranslate(-iCentreX, -iCentreY);

   674     }

   675 

   676 void CNvgEngine::ApplyScissoring(VGfloat aMatrix[], const TSize& aTargetSize)

   677     {

   678     /*

   679      * calculate the rectangle with respect to the transformation applied

   680      * and set the scissoring rect

   681      */ 

   682     TPoint leftBottom  = GetTranslatedPoint(aMatrix, TPoint(0, 0));

   683     TPoint leftTop     = GetTranslatedPoint(aMatrix, TPoint(0, aTargetSize.iHeight));

   684     TPoint rightBottom = GetTranslatedPoint(aMatrix, TPoint(aTargetSize.iWidth, 0));

   685     TPoint rightTop    = GetTranslatedPoint(aMatrix, TPoint(aTargetSize.iWidth,aTargetSize.iHeight));

   686 

   687     VGfloat minX = leftBottom.iX;

   688     VGfloat minY = leftBottom.iY;

   689     VGfloat maxX = leftBottom.iX;

   690     VGfloat maxY = leftBottom.iY;

   691 

   692     minX = MinVal4(leftBottom.iX, leftTop.iX, rightBottom.iX, rightTop.iX);

   693     minY = MinVal4(leftBottom.iY, leftTop.iY, rightBottom.iY, rightTop.iY);

   694 

   695     maxX = MaxVal4(leftBottom.iX, leftTop.iX, rightBottom.iX, rightTop.iX);

   696     maxY = MaxVal4(leftBottom.iY, leftTop.iY, rightBottom.iY, rightTop.iY);

   697 

   698     VGfloat newW = maxX - minX;

   699     VGfloat newH = maxY - minY;

   700 

   701     VGint clipRect[] = {minX, minY, newW, newH};

   702 

   703     vgSeti(VG_SCISSORING, VG_TRUE);

   704     vgSetiv(VG_SCISSOR_RECTS, 4,(const TInt32*) clipRect);

   705     }

   706 

   707 void CNvgEngine::ApplyViewboxToViewPortTransformationL(const TSize& aTargetSize, TReal32 aViewboxX, TReal32 aViewboxY, TReal32 aViewboxW, TReal32 aViewboxH)

   708     {

   709     CNvgFitToViewBoxImpl * viewboxTrnsfr =  CNvgFitToViewBoxImpl::NewL();

   710     CleanupStack::PushL(viewboxTrnsfr);

   711     /*

   712      * this is bit unreadable,

   713      * need to find a better design to separate the object caching solution from normal rendering,

   714      * but anyway I guess its better than those ifdef's, in that code scanner won't give any warnings

   715      */

   716     COND_COM_OC_NOC(

   717     {

   718     if (iInternal->iCreatingNVGIcon)

   719         {

   720         CSICON(iInternal->iCurrentNVGIcon)->SetViewBox(aViewboxX, aViewboxY, aViewboxW, aViewboxH);

   721         CSICON(iInternal->iCurrentNVGIcon)->SetPreserveAspectRatio(iPreserveAspectSetting, iSmilFitSetting);

   722         CSICON(iInternal->iCurrentNVGIcon)->Rotate(iRotateAngle, iCentreX, iCentreY);

   723         }

   724     else

   725         {

   726         viewboxTrnsfr->SetAlign(iPreserveAspectSetting);

   727         viewboxTrnsfr->SetScaling(iSmilFitSetting);

   728         

   729         if (aViewboxW > 0 && aViewboxH > 0)

   730             {

   731             viewboxTrnsfr->SetViewBox(aViewboxX, aViewboxY, aViewboxW, aViewboxH);

   732             }

   733         

   734         TInt lWidth = aTargetSize.iWidth;

   735         TInt lHeight = aTargetSize.iHeight;

   736         

   737         viewboxTrnsfr->SetWindowViewportTrans(TRect(0, 0, lWidth, lHeight), TSize(0, 0));

   738         

   739         }

   740     },

   741     {

   742     viewboxTrnsfr->SetAlign(iPreserveAspectSetting);

   743     viewboxTrnsfr->SetScaling(iSmilFitSetting);

   744     

   745     if (aViewboxW > 0 && aViewboxH > 0)

   746         {

   747         viewboxTrnsfr->SetViewBox(aViewboxX, aViewboxY, aViewboxW, aViewboxH);

   748         }

   749     

   750     TInt lWidth = aTargetSize.iWidth;

   751     TInt lHeight = aTargetSize.iHeight;

   752     

   753     viewboxTrnsfr->SetWindowViewportTrans(TRect(0, 0, lWidth, lHeight), TSize(0, 0));

   754     });

   755     

   756     CleanupStack::PopAndDestroy(viewboxTrnsfr);

   757     }

   758 

   759 TDereferencer GetCommandSectionL(TUint16 aOffset, TDereferencer * aIconData, TInt aNVGVersion)

   760     {

   761     // the max length that the command section can have

   762     TInt commandSectionLength = aIconData->GetLength() - aOffset;

   763 

   764     if (commandSectionLength <= 0)

   765         {

   766         User::Leave(KErrCorrupt);

   767         }

   768 

   769     TDereferencer section(aIconData->DerefInt8ArrayL(commandSectionLength, aOffset), commandSectionLength);

   770 

   771     /*

   772      * all the section are expected to be word aligned

   773      * all of the nvg-cs icon will be version 2 or above

   774      * the else won't be there as nvg version will always be greater than 2

   775      */

   776     if (aNVGVersion >= KVersion2)

   777         {

   778         if (!IsAligned4(aOffset))

   779             {

   780             User::Leave(KErrCorrupt);

   781             }

   782         }

   783     else

   784         {

   785         /*

   786          * no need to do anything here as once the nvgdecoder release

   787          * its version will be always greater than 2

   788          * infact the check for version will be removed

   789          */ 

   790         }

   791     

   792     return section;

   793     }

   794 

   795 void CNvgEngine::ExecuteNVGCSCommandLoopL(TUint16 aCommandCount, TDereferencer * aIconData, TDereferencer * aOffsetVector,

   796                                           TDereferencer * aCommandSection, TInt aNVGVersion)

   797     {

   798     TUint32 transVal;

   799 

   800     VGfloat lCurrentPathMatrix[9];

   801     

   802     vgGetMatrix(lCurrentPathMatrix);

   803     

   804     TInt32 lOffsetIx = 0;

   805     for (TInt i=0; i < aCommandCount; i++)

   806         {

   807         TUint32 currentCommand = aCommandSection->DerefInt32L();

   808         lOffsetIx = currentCommand & 0x0000ffff;

   809                 

   810         switch (currentCommand & 0xff000000)

   811             {

   812             case KCMD_SET_FILL_PAINT:

   813                 {

   814                 iFillAlpha        = (currentCommand & 0x00ff0000) >> 16;

   815                 TUint16 offset    = aOffsetVector->DerefInt16L(lOffsetIx * sizeof(TUint16));

   816                 

   817                 TDereferencer section = GetCommandSectionL(offset, aIconData, aNVGVersion);

   818                                 

   819                 SetFillPaintL(&section);

   820                 

   821                 break;

   822                 }

   823                 

   824             case KCMD_SET_COLOR_RAMP:

   825                 {

   826                 TUint16 offset = aOffsetVector->DerefInt16L(lOffsetIx * sizeof(TUint16));

   827 

   828                 TDereferencer section = GetCommandSectionL(offset, aIconData, aNVGVersion);

   829 

   830                 SetColorRampL(&section);

   831                 

   832                 break;

   833                 }

   834                 

   835             case KCMD_DRAW_PATH:

   836                 {

   837                 if ((currentCommand & 0x00010000)) 

   838                     {

   839                     idoStroke = VG_TRUE;

   840                     }

   841                 

   842                 if ((currentCommand & 0x00020000))

   843                     {

   844                     idoFill = VG_TRUE;

   845                     }

   846                 

   847                 if (idoStroke != VG_FALSE || idoFill != VG_FALSE)

   848                     {

   849                     TUint16 offset        = aOffsetVector->DerefInt16L(lOffsetIx * sizeof(TUint16));    

   850                     TDereferencer section = GetCommandSectionL(offset, aIconData, aNVGVersion);

   851     

   852                     DrawPathL(&section);

   853                     }

   854                 

   855                 break;

   856                 }

   857                 

   858             case KCMD_SET_TRANSFORMATION:

   859                 {

   860                 SetTransformL(aCommandSection, transVal, lCurrentPathMatrix);

   861                 aCommandSection->SkipL(transVal * sizeof(TUint32));

   862                 break;

   863                 }

   864                 

   865             case KCMD_SET_STROKE_PAINT:

   866                 {

   867                 iStrokeAlpha = (currentCommand & 0x00ff0000) >> 16;

   868                 TUint16 offset = aOffsetVector->DerefInt16L(lOffsetIx * sizeof(TUint16));

   869 

   870                 TDereferencer section = GetCommandSectionL(offset, aIconData, aNVGVersion);

   871 

   872                 SetStrokePaintL(&section);

   873                 

   874                 break;

   875                 }

   876 

   877             case KCMD_SET_STROKE_WIDTH:

   878                 {

   879                 TReal32 lStrokeWidth;

   880                 aCommandSection->SkipL(sizeof(TUint32));

   881                 

   882                 /*

   883                  * check for alignment and copy data if not aligned, else directly convert

   884                  * version 2 or above guarantees that is always word aligned

   885                  */

   886                 TUint8 * cptr = aCommandSection->DerefInt8ArrayL(sizeof(TReal32), 0); 

   887                 if (aNVGVersion < KVersion2 && !IsAligned4(cptr))

   888                     {

   889                     

   890                     Mem::Copy(reinterpret_cast<void *>(&lStrokeWidth),

   891                               reinterpret_cast<void *>(cptr), sizeof(lStrokeWidth));

   892                     }

   893                 else

   894                     {

   895                     lStrokeWidth = aCommandSection->DerefReal32L();

   896                     }

   897                 

   898                 COND_COM_OC(iInternal->iCreatingNVGIcon,

   899                         CSICON(iInternal->iCurrentNVGIcon)->AddSetStrokeWidthCommandL(lStrokeWidth),

   900                         vgSetf(VG_STROKE_LINE_WIDTH, lStrokeWidth));

   901                 break;

   902                 }

   903                 

   904             case KCMD_SET_STROKE_MITER_LIMIT:

   905                 {

   906                 TReal32 lMiterLimit;

   907                 aCommandSection->SkipL(sizeof(TUint32));

   908 

   909                 /*

   910                  * check for alignment and copy data if not aligned, else directly convert

   911                  * version 2 or above guarantees that is always word aligned

   912                  */

   913                 TUint8 * cptr = aCommandSection->DerefInt8ArrayL(sizeof(TReal32), 0); 

   914 

   915                 if (aNVGVersion < KVersion2 && !IsAligned4(cptr))

   916                     {

   917                     Mem::Copy(reinterpret_cast<void *>(&lMiterLimit),

   918                               reinterpret_cast<void *>(cptr), sizeof(lMiterLimit));

   919                     }

   920                 else

   921                     {

   922                     lMiterLimit = aCommandSection->DerefReal32L();

   923                     }

   924                 

   925                 COND_COM_OC(iInternal->iCreatingNVGIcon,

   926                         CSICON(iInternal->iCurrentNVGIcon)->AddSetStrokeMiterLimitCommandL(lMiterLimit),

   927                         vgSetf(VG_STROKE_MITER_LIMIT, lMiterLimit));

   928                 

   929                 break;

   930                 }

   931                 

   932             case KCMD_SET_STROKE_LINE_JOIN_CAP:

   933                 {

   934                 TUint8 lJoinType =(currentCommand & 0x0000ff00)>>8;

   935                 TUint8 lCapType = (currentCommand & 0x000000ff);

   936                 

   937                 VGCapStyle capStyle;

   938                 switch(lCapType)

   939                     {

   940                     case KCAP_SQUARE:

   941                         capStyle = VG_CAP_SQUARE;

   942                         break;

   943                     case KCAP_ROUND:

   944                         capStyle = VG_CAP_ROUND;

   945                         break;

   946                     case KCAP_BUTT:

   947                     default:

   948                         capStyle = VG_CAP_BUTT;

   949                         break;

   950                     }

   951    

   952                 VGJoinStyle lineJoinStyle;

   953                 switch(lJoinType)

   954                     {

   955                     case KLINE_JOIN_BEVEL:

   956                         lineJoinStyle = VG_JOIN_BEVEL;

   957                         break;

   958                     case KLINE_JOIN_ROUND:

   959                         lineJoinStyle = VG_JOIN_ROUND;

   960                         break;

   961                     case KLINE_JOIN_MITER:

   962                     default:

   963                         lineJoinStyle = VG_JOIN_MITER;

   964                         break;

   965                     }

   966                 

   967                 COND_COM_OC(iInternal->iCreatingNVGIcon,

   968                         CSICON(iInternal->iCurrentNVGIcon)->AddStrokeLineJoinCapCommandL(capStyle, lineJoinStyle),

   969                         vgSeti(VG_STROKE_CAP_STYLE, capStyle);

   970                         vgSeti(VG_STROKE_JOIN_STYLE, lineJoinStyle););

   971                 break;

   972                 }

   973                 

   974             default:

   975                 {

   976                 User::Leave(KErrCorrupt);

   977                 break;

   978                 }

   979             }

   980         

   981         // go to the next command

   982         aCommandSection->SkipL(sizeof(TUint32));

   983         }

   984     }

   985 

   986 EXPORT_C void CNvgEngine::SetPreserveAspectRatio(

   987         TNvgAlignStatusType aPreserveAspectSetting, 

   988         TNvgMeetOrSliceType aSmilFitSetting)

   989     {

   990     iPreserveAspectSetting = aPreserveAspectSetting;

   991     iSmilFitSetting = aSmilFitSetting;

   992     }

   993 

   994 EXPORT_C void CNvgEngine::SetBackgroundColor(TUint32 aRGBA8888Color)

   995     {

   996     iBackgroundColor = aRGBA8888Color;

   997     }

   998 

   999 TInt CNvgEngine::SetFillPaintL(TDereferencer * aIconData)

  1000     {

  1001     COND_COM_OC_OOC(register int drawingMode = iInternal->iCreatingNVGIcon);

  1002     

  1003     TUint32 lCommonData  = aIconData->DerefInt32L();

  1004     TUint lPaintType     = lCommonData & 0x07;

  1005     TUint16 lSpecifcData = (lCommonData >> 16) & 0xff;

  1006     

  1007     switch (lPaintType)

  1008         {

  1009         case KPAINT_LGRAD:

  1010             {

  1011             iGradPaintFill = iPaintFill;

  1012             

  1013             COND_COM_OC_OOC(

  1014             if (iInternal->iCreatingNVGIcon)

  1015                 {

  1016                 // CNVGCSIcon will destroy the paint handle

  1017                 iGradPaintFill = vgCreatePaint();

  1018                 if (iGradPaintFill == VG_INVALID_HANDLE)

  1019                     {

  1020                     User::LeaveIfError(CNvgEngine::OpenVGErrorToSymbianError(vgGetError()));

  1021                     }

  1022                 });

  1023 

  1024             // gradient data, the data will be word aligned

  1025             TReal32* lGradData = (TReal32*)aIconData->DerefInt8ArrayL(4 * sizeof(VGfloat), sizeof(TUint32));

  1026             

  1027             vgSetParameteri(iGradPaintFill, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);

  1028             vgSetParameterfv(iGradPaintFill, VG_PAINT_LINEAR_GRADIENT, 4, lGradData);

  1029             vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);

  1030             

  1031             if (lSpecifcData & 0x1)

  1032                 {

  1033                 TReal32* lGradMatrix1 = (TReal32*) aIconData->DerefInt8ArrayL(6 * sizeof (VGfloat),

  1034                                                     KNVG_PAINTSECTION_LINEARGRAD_TRANSFORM_OFFSET);

  1035                 

  1036                 TReal32 lGradMatrix[9] = {lGradMatrix1[0], lGradMatrix1[3], 0.0f,  

  1037                         lGradMatrix1[1], lGradMatrix1[4], 0.0f,

  1038                         lGradMatrix1[2], lGradMatrix1[5], 1.0f};

  1039                 

  1040                 COND_COM_OC(drawingMode,

  1041                         CSICON(iInternal->iCurrentNVGIcon)->AddLinearGradientCommandL(4, lGradData, lGradMatrix, iGradPaintFill),

  1042                         vgLoadMatrix(lGradMatrix););

  1043                 }

  1044             else

  1045                 {

  1046                 COND_COM_OC(drawingMode,

  1047                         CSICON(iInternal->iCurrentNVGIcon)->AddLinearGradientCommandL(4, lGradData, (VGfloat*)KIdentityMatrix, iGradPaintFill),

  1048                         vgLoadIdentity());

  1049                 }

  1050             

  1051             COND_COM_OC(drawingMode, ;,

  1052                      vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE));

  1053             

  1054             break;

  1055             }

  1056             

  1057         case KPAINT_RGRAD:

  1058             {

  1059             // gradient data, the data will be word aligned

  1060             TReal32* lGradData = (TReal32*)aIconData->DerefInt8ArrayL(5 * sizeof(VGfloat), sizeof(TUint32));

  1061             iGradPaintFill = iPaintFill;

  1062             

  1063             COND_COM_OC_OOC(

  1064             if (iInternal->iCreatingNVGIcon)

  1065                 {

  1066                 iGradPaintFill = vgCreatePaint();

  1067                 if (iGradPaintFill == VG_INVALID_HANDLE)

  1068                     {

  1069                     User::LeaveIfError(CNvgEngine::OpenVGErrorToSymbianError(vgGetError()));

  1070                     }                

  1071                 });

  1072 

  1073             vgSetParameteri(iGradPaintFill, VG_PAINT_TYPE, VG_PAINT_TYPE_RADIAL_GRADIENT);

  1074             vgSetParameterfv(iGradPaintFill, VG_PAINT_RADIAL_GRADIENT, 5, lGradData);

  1075             vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);

  1076 

  1077 

  1078             if (lSpecifcData & 0x1)

  1079                 {

  1080                 TReal32* lGradMatrix1 = (TReal32*)aIconData->DerefInt8ArrayL(6 * sizeof (VGfloat),

  1081                                                    KNVG_PAINTSECTION_RADIALGRAD_TRANSFORM_OFFSET);

  1082                 

  1083                 TReal32 lGradMatrix[9] = {lGradMatrix1[0], lGradMatrix1[3], 0.0f,  

  1084                         lGradMatrix1[1], lGradMatrix1[4], 0.0f,

  1085                         lGradMatrix1[2], lGradMatrix1[5], 1.0f};

  1086                 

  1087                 COND_COM_OC(drawingMode,

  1088                         CSICON(iInternal->iCurrentNVGIcon)->AddRadialGradientCommandL(5, lGradData, lGradMatrix, iGradPaintFill),

  1089                         vgLoadMatrix(lGradMatrix));

  1090                 }

  1091             else

  1092                 {

  1093                 COND_COM_OC(drawingMode,

  1094                         CSICON(iInternal->iCurrentNVGIcon)->AddRadialGradientCommandL(5, lGradData, (VGfloat*)KIdentityMatrix, iGradPaintFill),

  1095                         vgLoadIdentity());

  1096                 }

  1097             

  1098             COND_COM_OC(drawingMode, ;,

  1099                     vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE));

  1100             break;

  1101             }

  1102             

  1103         case KPAINT_FLAT:

  1104             {

  1105             TUint32 lRgba = aIconData->DerefInt32L(KNVG_RGBA_OFS);

  1106 

  1107             lRgba = (lRgba & 0xffffff00) | iFillAlpha;

  1108             

  1109             COND_COM_OC(drawingMode,

  1110                     CSICON(iInternal->iCurrentNVGIcon)->AddSetColorCommandL(lRgba),

  1111                     vgSetParameteri(iPaintFill, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);

  1112                     vgSetColor(iPaintFill, lRgba));            

  1113             break;

  1114             }

  1115             

  1116         default:

  1117             {

  1118             User::Leave(KErrCorrupt);

  1119             break;

  1120             }

  1121         }

  1122     return KErrNone;

  1123     }

  1124 

  1125 TInt CNvgEngine::SetColorRampL(TDereferencer * aIconData)

  1126     {

  1127     TUint32 lCommonData = aIconData->DerefInt32L();

  1128     

  1129     TInt lStopCount = (lCommonData >> 16) & 0x00ff;

  1130     TReal32* lStopData = (TReal32*)aIconData->DerefInt8ArrayL(lStopCount * 5 * sizeof(TReal32), sizeof(TUint32));

  1131     

  1132     VGfloat * colorRamps = new (ELeave) VGfloat[lStopCount * 5];

  1133     CleanupStack::PushL(TCleanupItem(CleanupArray, colorRamps));

  1134         

  1135     if (iFillAlpha == 0xff)