/*

* Copyright (c) 2008 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:  NVG Decoder source file

*

*/

#include <s32mem.h>

#include <libc/math.h> 

#include <e32math.h>

#include "nvg.h"

#include "nvgfittoviewbox.h"

#include "NVGUtil.h"

#include "NVGCSIcon.h"

#include "NVGTLVIcon.h"

#include "FloatFixPt.h"

#include "NVGIconData.h"

/*

 * may be we should use dynamic_cast?

 */

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

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

enum TNVGFormats

    {

    ENVGCS,

    ENVGTLV

    };

/*

 *  NVG-CS version

 */

//const TInt KVersion1   = 1;

const TInt KVersion2   = 2;

/*

 * constants for nvg file header offsets

 */ 

const TUint8 KNVG_SIGNATURE[]       = "nvg";

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

const TInt KNVG_COMMANDSECTION_OFS  = 2;

const TInt KNVG_VERSION_OFS         = 3;

const TInt KNVG_RGBA_OFS            = 4;

const TInt KNVG_HEADERSIZE_OFS      = 4;

const TInt KNVG_PATHDATATYPE_OFS    = 26;

const TInt KNVG_SCALE_OFS           = 28;

const TInt KNVG_BIAS_OFS            = 32;

const TInt KNVG_VIEWBOX_X_OFS       = 36;

const TInt KNVG_VIEWBOX_Y_OFS       = 40;

const TInt KNVG_VIEWBOX_WIDTH_OFS   = 44;

const TInt KNVG_VIEWBOX_HEIGHT_OFS  = 48;

const TInt KNVG_PAINTSECTION_LINEARGRAD_TRANSFORM_OFFSET = 20;

const TInt KNVG_PAINTSECTION_RADIALGRAD_TRANSFORM_OFFSET = 24;

/*

 * nvg-cs commands

 */ 

const TInt KCMD_SET_FILL_PAINT           = 4  << 24;

const TInt KCMD_SET_COLOR_RAMP           = 6  << 24;

const TInt KCMD_DRAW_PATH                = 7  << 24;

const TInt KCMD_SET_TRANSFORMATION       = 8  << 24;

const TInt KCMD_SET_STROKE_PAINT         = 5  << 24;

const TInt KCMD_SET_STROKE_WIDTH         = 9  << 24;

const TInt KCMD_SET_STROKE_LINE_JOIN_CAP = 10 << 24;

const TInt KCMD_SET_STROKE_MITER_LIMIT   = 11 << 24;

/*

 * stroke cap style

 */

const TInt KCAP_BUTT        = 1;

const TInt KCAP_SQUARE      = 2;

const TInt KCAP_ROUND       = 3;

/*

 * stroke join style

 */

const TInt KLINE_JOIN_BEVEL = 1;

const TInt KLINE_JOIN_MITER = 2;

const TInt KLINE_JOIN_ROUND = 3;

/*

 * fill paint type

 */

const TInt KPAINT_FLAT      = 1;

const TInt KPAINT_LGRAD     = 2;

const TInt KPAINT_RGRAD     = 3;

/*

 * stroke paint type

 */

const TInt KSTROKE_LGRAD        = 2;

const TInt KSTROKE_RGRAD        = 3;

const TInt KSTROKE_COLOR_RAMP   = 4;

/*

 * nvg offset

 */

const TInt KOffsetReserved1       = 6;

/*

 * transform encoding values

 */

const TInt KTRANSFORM_COMPLETE    = 0;

const TInt KTRANSFORM_SCALING     = 2;

const TInt KTRANSFORM_SHEARING    = 4;

const TInt KTRANSFORM_ROTATION    = 8;

const TInt KTRANSFORM_TRANSLATION = 16;

#ifdef OPENVG_OBJECT_CACHING

const VGfloat KIdentityMatrix[] = 

    {

    1.0f, 0.0f, 0.0f,

    0.0f, 1.0f, 0.0f,

    0.0f, 0.0f ,1.0f

    };

#endif

/*

 * function to delete array, for basic types

 */

GLDEF_C void CleanupArray( TAny * aObj )

    {

    delete [] aObj;

    }

/*

 * function to delete array of TFloatFixArray

 */

GLDEF_C void CleanupTFloatFixArray( TAny * aObj )

    {

    TFloatFixPt * ff = (TFloatFixPt *)aObj;

    delete [] ff;

    }

/**

 * @class   TNVGEngineInternal

 * This class is added to maintain BC.

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

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

 */

class TNVGEngineInternal

    {

public:

    TNVGEngineInternal()

        {

#ifdef    OPENVG_OBJECT_CACHING

        iCreatingNVGIcon = 0;

        iCurrentNVGIcon  = 0;

#endif

        }

#ifdef    OPENVG_OBJECT_CACHING

    TInt        iCreatingNVGIcon;

    MNVGIcon *  iCurrentNVGIcon;

#endif

    };

CNvgEngine::CNvgEngine()

    : iCurrentBufferSize(1, 1),

      iPath(VG_INVALID_HANDLE),

      iPaintFill(VG_INVALID_HANDLE),

      iPaintStroke( VG_INVALID_HANDLE),

      iUserStrokePaintColor(0xFFFFFFFF),

      iRotateApplied(EFalse),

      iLastPathDataType(0),

      iPreserveAspectSetting(ENvgPreserveAspectRatio_XmidYmid),

      iSmilFitSetting(ENvgMeet),

      iVGImageBinder(0)

    {

    }

EXPORT_C CNvgEngine* CNvgEngine::NewL()

    {

    CNvgEngine* self    = new (ELeave) CNvgEngine;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CNvgEngine::ConstructL()

    {

    vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);

    vgSeti(VG_FILL_RULE, VG_NON_ZERO);

    iInternal = new (ELeave) TNVGEngineInternal;

    iPaintFill = vgCreatePaint();

    }

EXPORT_C CNvgEngine::~CNvgEngine()

    {

    if (iPath != VG_INVALID_HANDLE)

        {

        vgDestroyPath(iPath);

        }

    if (iPaintFill != VG_INVALID_HANDLE)

        {

        vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);

        vgDestroyPaint(iPaintFill);

        }

    if (iPaintStroke != VG_INVALID_HANDLE)

        {

        vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH);

        vgDestroyPaint(iPaintStroke);

        }

#ifdef    OPENVG_OBJECT_CACHING

    if (iInternal)

        {

        delete iInternal->iCurrentNVGIcon;

        }

#endif

    delete iInternal;

    }

/**

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

 * @version

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

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

 * @return  None

 */

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

    {

    if(aAngle)

        {

        iRotateApplied  = ETrue;

        iCentreX        = aCentreX;

        iCentreY        = aCentreY;

        iRotateAngle    = aAngle;

        }

    else

        {

        iRotateApplied  = EFalse;

        iCentreX        = 0;

        iCentreY        = 0;

        iRotateAngle    = 0;

        }

    }

/**

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

 * @version

 * @param   aBuf NVG byte data of the file

 * @return  content dimension

 */

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

    {

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

        {

        return TSize(0, 0);

        }

    const TUint8* lBuf = aBuf.Ptr();

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

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

    if (lViewboxWidth > 0 && lViewboxHeight > 0)

        {

        return TSize(lViewboxWidth, lViewboxHeight);

        }

    else

        {

        return TSize(0, 0);

        }

    }

TInt CNvgEngine::InitializeGC()

    {

    if (iPaintFill == VG_INVALID_HANDLE)

        {

        iPaintFill = vgCreatePaint();

        if (iPaintFill == VG_INVALID_HANDLE)

            {

            return OpenVGErrorToSymbianError(vgGetError());

            }

        }

    vgSetPaint(iPaintFill, VG_FILL_PATH);

    if (iPaintStroke == VG_INVALID_HANDLE)

        {

        iPaintStroke = vgCreatePaint();

        if (iPaintStroke == VG_INVALID_HANDLE)

            {

            return OpenVGErrorToSymbianError(vgGetError());

            }

        }

    vgSetPaint( iPaintStroke, VG_STROKE_PATH);

    return KErrNone;

    }

EXPORT_C void CNvgEngine::ResetNvgState()

    {

    if (iPath != VG_INVALID_HANDLE)

        {

        vgDestroyPath(iPath);

        iPath = VG_INVALID_HANDLE;

        }

    if (iPaintFill != VG_INVALID_HANDLE)

        {

        vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);

        vgDestroyPaint(iPaintFill);

        iPaintFill = VG_INVALID_HANDLE;

        }

    if (iPaintStroke != VG_INVALID_HANDLE)

        {

        vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH);

        vgDestroyPaint(iPaintStroke);

        iPaintStroke = VG_INVALID_HANDLE;

        }

    }

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

    {

    TInt error = KErrNone;

    /*

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

     */ 

    UpdateClientMatrices();

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

    /*

     * restore everything as we may have changed matrix mode

     */             

    RestoreClientMatrices();

	vgSeti(VG_SCISSORING, VG_FALSE);

	if (error)

	    {

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

	    }

    return error;

    }

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

    {    

    NVG_DEBUGP1("Creating NVGCSIcon");

    MNVGIcon * nvgIcon = 0;

    /*

     * this is bit unreadable,

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

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

     */

    COND_COM_OC_NOC(

    {

    if (iInternal->iCurrentNVGIcon)

        {

        delete iInternal->iCurrentNVGIcon;

        }

    iInternal->iCurrentNVGIcon     = 0;

    iInternal->iCreatingNVGIcon    = 1;

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

        {

        delete iInternal->iCurrentNVGIcon;

        iInternal->iCurrentNVGIcon = 0;

        }

    iInternal->iCreatingNVGIcon    = 0;

    nvgIcon = iInternal->iCurrentNVGIcon;

    iInternal->iCurrentNVGIcon = 0;

    },

    {

    (void)aBuf;

    (void)aSize;

    });

    return nvgIcon;

    }

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

    {

    TInt drawStatus = KErrNone;

    if (iCurrentBufferSize != aSize)

        { 

        iCurrentBufferSize = aSize;

        }

    iDstBimtap = aDstBitmap;

    TDereferencer nvgIconData(aBuffer);

    TUint8 * signature = nvgIconData.DerefInt8ArrayL(KNVG_SIGNATURE_LENGTH);

    // checking the 'nvg' signature

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

        {

        NVG_DEBUGP1("Not an NVG icon");

        User::Leave(KErrNotSupported);

        }

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

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

    switch (nvgType)

        {

        case ENVGCS:

            {

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

            break;

            }

        case ENVGTLV:

            {

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

            break;

            }

        default:

            drawStatus = KErrNotSupported;

            break;

        }

    User::LeaveIfError(drawStatus);

    }

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

    {

    TInt ret = KErrNone;

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

    VGfloat origMatrix[9];

    vgGetMatrix(origMatrix);

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE); 

    vgLoadMatrix(origMatrix);

#ifndef __MIRROR_

    vgScale(1.0f, -1.0f);

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

#endif

    /*

     * this is bit unreadable,

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

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

     */

    COND_COM_OC_NOC(

    {

    if (iInternal->iCreatingNVGIcon)

        {

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

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

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

        }

    else

        {

        CNVGTLVIcon * tlvIcon = CNVGTLVIcon::NewL();

        CleanupStack::PushL(tlvIcon);

        tlvIcon->SetVGImageBinder(iVGImageBinder);

        tlvIcon->DirectDrawL(aBuf, aTargetSize);

        CleanupStack::PopAndDestroy(tlvIcon);        

        }

    },

    {

    CNVGTLVIcon * tlvIcon = CNVGTLVIcon::NewL();

    CleanupStack::PushL(tlvIcon);

    TLVICON(tlvIcon)->SetVGImageBinder(iVGImageBinder);

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

    CleanupStack::PopAndDestroy(tlvIcon);                    

    });

    vgSeti(VG_SCISSORING, VG_FALSE);

    return ret;

    }

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

    {

    (void) aScale;

    (void) aBias;

    TInt error = KErrNone;

    if (iLastPathDataType != aPathDataType)

        {

        if (iPath != VG_INVALID_HANDLE)

            {

            vgDestroyPath(iPath);

            iPath = VG_INVALID_HANDLE;

            }

        }

    if (iPath == VG_INVALID_HANDLE)

        {

        switch (aPathDataType)

            {

            case EEightBitEncoding:

                {

                iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,

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

                VG_PATH_CAPABILITY_APPEND_TO);            

                }

                break;

            case ESixteenBitEncoding:

                {

                iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,

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

                VG_PATH_CAPABILITY_APPEND_TO);