/*

* 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 "TLVRenderer.h"

#include "MVGImageBinder.h"

#include "NVGUtil.h"

#include "NVGIconData.h"

#include "NVGTLVIcon.h"

#include "nvg.h"

#ifdef NVG_DEBUG

#include <time.h>

#endif

CTLVRenderer::CTLVRenderer(TInt aWidth, TInt aHeight)

        : iTargetWidth(aWidth),

          iTargetHeight(aHeight),

          iVGImageBinder(0),

          iPrepareToBindImage(0)

    {

    }

CTLVRenderer * CTLVRenderer::NewL(const TDesC8& aBuf, TInt aWidth, TInt aHeight)

    {

    CTLVRenderer* self  = CTLVRenderer::NewLC(aBuf,aWidth, aHeight);

    CleanupStack::Pop(self);

    return self;

    }

CTLVRenderer * CTLVRenderer::NewLC(const TDesC8& aBuf, TInt aWidth, TInt aHeight)

    {

    CTLVRenderer* self    = new (ELeave) CTLVRenderer(aWidth, aHeight);

    CleanupStack::PushL(self);

    self->ConstructL(aBuf);

    return self;

    }

void CTLVRenderer::ConstructL(const TDesC8& aBuf)

    {

    vgapi[EvgSeti]              = &DvgSetiL;

    vgapi[EvgSetf]              = &DvgSetfL;

    vgapi[EvgSetParameteri]     = &DvgSetParameteriL;

    vgapi[EvgSetParameterf]     = &DvgSetParameterfL;

    vgapi[EvgSetParameterfv]    = &DvgSetParameterfvL;

    vgapi[EvgSetColor]          = &DvgSetColorL;

    vgapi[EvgSetPaint]          = &DvgSetPaintL;

    vgapi[EvgLoadMatrix]        = &DvgLoadMatrixL;

    vgapi[EvgMultMatrix]        = &DvgMultMatrixL;

    vgapi[EvgLoadIdentity]      = &DvgLoadIdentityL;

    vgapi[EvgScale]             = &DvgScaleL;

    vgapi[EvgTranslate]         = &DvgTranslateL;

    vgapi[EvgAppendPathData]    = &DvgAppendPathDataL;

    vgapi[EvgDrawPath]          = &DvgDrawPathL;

    vgapi[EvgClearPath]         = &DvgClearPathL;

    vgapi[EvguRect]             = &DvguRectL;

    vgapi[EvguEllipse]          = &DvguEllipseL;

    vgapi[EvguRoundRect]        = &DvguRoundRectL;

    vgapi[EvguLine]             = &DvguLineL;

    vgapi[EvgCreatePaint]       = &DvgCreatePaintL;

    vgapi[EvgSetiv]             = &DvgSetivL;

    vgapi[EvgClear]             = &DvgClearL;

    vgapi[EvgSetfv]             = &DvgSetfvL;

    vgapi[EvgRotate]            = &DvgRotateL;

    vgapi[EvgCreatePath]        = &DvgCreatePathL;

    vgapi[EvgCreateImage]       = &DvgCreateImageL;

    vgapi[EvgGetPixels]         = &DvgGetPixelsL;

    vgapi[EvgDrawImage]         = &DvgDrawImageL;

    vgapi[EvgClearImage]        = &DvgClearImageL;

    vgapi[EvgImageSubData]      = &DvgImageSubDataL;

    vgapi[EvgDestroyImage]      = &DvgDestroyImageL;

    vgapi[EvgDestroyPaint]      = &DvgDestroyPaintL;

    vgapi[EvgDestroyPath]       = &DvgDestroyPathL;

    vgapi[EvgPrepareToBindImage]= &DvgPrepareToBindImageL;

    vgapi[EvgBindImage]         = &DvgBindImageL;

    vgapi[EvgUnBindImage]       = &DvgUnBindImageL;

    vgapi[EvgFlush]             = &DvgFlushL;

    vgGetMatrix(iUserMatrix);

    iNVGIconData = CNVGIconData::NewL(aBuf);

    iDataLength  = aBuf.Length();

    iNVGIconData->BeginRead();

    iNVGIconData->ReadL(iNvgHeader, sizeof(iNvgHeader));

    INIT_HANDLECHECKER()

    }

CTLVRenderer::~CTLVRenderer()

    {

    if (iPathHandle != VG_INVALID_HANDLE)

        {

        VGDESTROYPATH(iPathHandle);

        }

    TInt handleListCount    = iTLVVGHandleList.Count();

    if (handleListCount > 0)

        {

        vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);

        vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH);

        }

    for (TInt i = 0; i < handleListCount; i++)

        {

        if (iTLVVGHandleList[i].iVGHandle)

            {

            switch (iTLVVGHandleList[i].iHandleType)

                {

                case TLVVGHandlePair::EVGPATH:

                    VGDESTROYPATH(iTLVVGHandleList[i].iVGHandle);

                    break;

                case TLVVGHandlePair::EVGPAINT:

                    VGDESTROYPAINT(iTLVVGHandleList[i].iVGHandle);

                    break;

                case TLVVGHandlePair::EVGIMAGE:

                    VGDESTROYIMAGE(iTLVVGHandleList[i].iVGHandle);

                    break;

                }

            }

        }

    iTLVVGHandleList.Close();

    if (iNVGIconData)

        {

        iNVGIconData->EndRead();    

        delete iNVGIconData;

        }

    ASSERT_HANDLE_COUNT()

    }

void CTLVRenderer::DvgSetiL()

    {

    TUint16 type;

    TUint16 value;

    type = iNVGIconData->ReadInt16L();

    value = iNVGIconData->ReadInt16L();

    //if ((VGParamType)LargVGParam_value != VG_SCISSORING)

        {

        vgSeti((VGParamType)type, value);

        }

    NVG_DEBUGSTMT(LogvgSeti((VGParamType)type, value));

    }

void CTLVRenderer::DvgSetfL()

    {

    TUint16 type   = iNVGIconData->ReadInt16L();

    VGfloat value     = iNVGIconData->ReadReal32L();

    vgSetf((VGParamType)type, value);

    NVG_DEBUGSTMT(LogvgSetf((VGParamType)type, value));

    }

void CTLVRenderer::DvgSetParameteriL()

    {

    TUint  handle;

    TUint16 type;

    TUint16 value;

    handle = iNVGIconData->ReadInt32L();

    type = iNVGIconData->ReadInt16L();

    value = iNVGIconData->ReadInt16L();

    vgSetParameteri(GetHandleL(handle), type, value);

    NVG_DEBUGSTMT(LogvgSetParameteri(GetHandleL(handle), type, value, handle));

    }

void CTLVRenderer::DvgSetParameterfL()

    {

    TUint handle = iNVGIconData->ReadInt32L();

    TUint16 type = iNVGIconData->ReadInt16L();

    TUint32 value = iNVGIconData->ReadReal32L();

    vgSetParameterf(GetHandleL(handle), type, value);

    NVG_DEBUGP4("vgSetParameterf(%d, %d, %d);\n", handle, type, value);

    }

void CTLVRenderer::DvgSetParameterfvL()

    {

    TUint handle = iNVGIconData->ReadInt32L();

    TUint16 type = iNVGIconData->ReadInt16L();

    float * value;

    TUint32 count = iNVGIconData->ReadInt32L();

    value = new (ELeave) float[count];

    CleanupStack::PushL(TCleanupItem(CleanupArray, value));

    for(int i=0; i<count; i++)

        {

        value[i] = iNVGIconData->ReadReal32L();

        }

    vgSetParameterfv(GetHandleL(handle), type, count, value);

    NVG_DEBUGSTMT(LogvgSetParameterfv(GetHandle(handle), type, count, value));

    CleanupStack::PopAndDestroy();

    }

void CTLVRenderer::DvgSetColorL()

    {

    TUint paintvalue = iNVGIconData->ReadInt32L();

    TUint32 rgba = iNVGIconData->ReadInt32L();

    vgSetColor(GetHandleL(paintvalue), rgba);

    NVG_DEBUGP6("vgSetColor(%d, ((%d << 24) | (%d << 16) | (%d << 8) | %d));\n", GetHandleL(paintvalue), (rgba & 0xFF000000) >> 24, (rgba & 0x00FF0000) >> 16,

            (rgba & 0x0000FF00) >> 8, (rgba & 0x000000FF));

    }

void CTLVRenderer::DvgSetPaintL()

    {

    TUint paintvalue = iNVGIconData->ReadInt32L();

    TUint8 value = iNVGIconData->ReadInt8L();

    vgSetPaint(GetHandleL(paintvalue), value);

    NVG_DEBUGSTMT(LogvgSetPaint(GetHandleL(paintvalue), value, paintvalue));

    }

TPoint CTLVRenderer::GetTranslatedPoint(VGfloat aTRMatrix[9], TPoint aPoint)

    {

    TPoint trPoint;

    trPoint.iX = aTRMatrix[0] * aPoint.iX + aTRMatrix[3] * aPoint.iY + aTRMatrix[6];

    trPoint.iY = aTRMatrix[1] * aPoint.iX + aTRMatrix[4] * aPoint.iY + aTRMatrix[7];

    return trPoint;

    }

VGfloat CTLVRenderer::MinVal4(VGfloat x1, VGfloat x2, VGfloat x3, VGfloat x4 )

    {

    VGfloat min = x1;

    if (min > x2)

        {

        min = x2;

        }

    if (min > x3)

        {

        min = x3;

        }

    if (min > x4)

        {

        min = x4;

        }

    return min;

    }

VGfloat CTLVRenderer::MaxVal4(VGfloat x1, VGfloat x2, VGfloat x3, VGfloat x4 )

    {

    VGfloat max = x1;

    if (max < x2)

        {

        max = x2;

        }

    if (max < x3)

        {

        max = x3;

        }

    if (max < x4)

        {

        max = x4;

        }

    return max;

    }

void CTLVRenderer::DvgSetivL()

    {

    TUint16 type = iNVGIconData->ReadInt16L();

    TUint16 count = iNVGIconData->ReadInt16L();

    VGint * value;

    value = new (ELeave) VGint[count];

    CleanupStack::PushL(TCleanupItem(CleanupArray, value));

    for(int i = 0; i < count; i++)

        {

        value[i] = iNVGIconData->ReadInt32L();

        }

    if (type == VG_SCISSOR_RECTS)

        {

        VGfloat * matrix = iUserMatrix;

        // calculate the rectangle with respect to the transformation applied

        for(int i = 0; i < count; i += 4)

            {

            TInt sx = i + 0;

            TInt sy = i + 1;

            TInt sw = i + 2;

            TInt sh = i + 3;

            TPoint leftBottom  = GetTranslatedPoint(matrix,

                                        TPoint(value[sx], value[sy]));

            TPoint leftTop     = GetTranslatedPoint(matrix,

                                        TPoint(value[sx], value[sy] + value[sh]));

            TPoint rightBottom = GetTranslatedPoint(matrix,

                                        TPoint(value[sx] + value[sw], value[sy]));

            TPoint rightTop    = GetTranslatedPoint(matrix,

                                        TPoint(value[sx] + value[sw], value[sy] + value[sh]));

            VGfloat minX = leftBottom.iX;

            VGfloat minY = leftBottom.iY;

            VGfloat maxX = leftBottom.iX;

            VGfloat maxY = leftBottom.iY;

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

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

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

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

            VGfloat newW = maxX - minX;

            VGfloat newH = maxY - minY;

            value[sx] = minX;

            value[sy] = minY;

            value[sw] = newW;

            value[sh] = newH;

            /*

            if (newW > iTargetWidth)

                {

                newW = iTargetWidth;

                }

            if (newH > iTargetHeight)

                {

                newH = iTargetHeight;

                }

             */

            }

        }

    vgSetiv((VGParamType)type, count, value);

    NVG_DEBUGSTMT(LogvgSetXv((VGParamType)type, count, 'i', value));

    CleanupStack::PopAndDestroy();

    }

void CTLVRenderer::DvgLoadMatrixL()

    {

    VGfloat matrix[9];

    for(int i=0;i<9;i++)

        {

        matrix[i] = iNVGIconData->ReadReal32L();

        }

    // keep the caller's matrix as base

    TInt matrixMode = vgGeti(VG_MATRIX_MODE);

    if (matrixMode == VG_MATRIX_PATH_USER_TO_SURFACE ||

        matrixMode == VG_MATRIX_IMAGE_USER_TO_SURFACE /* need to check?*/)

        {

        vgLoadMatrix(iUserMatrix);

        vgMultMatrix(matrix);

        }

    else

        {

        vgLoadMatrix(matrix);

        }

#ifdef NVG_DEBUG

    int matrixCount = clock() % 1000;

    NVG_DEBUGP2("VGfloat ldMatrix%d[] = {", matrixCount);

    NVG_DEBUGP4("    %f, %f, %f, ", matrix[0], matrix[1], matrix[2]);

    NVG_DEBUGP4("    %f, %f, %f, ", matrix[3], matrix[4], matrix[5]);

    NVG_DEBUGP4("    %f, %f, %f};\n", matrix[6], matrix[7], matrix[8]);

    NVG_DEBUGP2("vgLoadMatrix(ldMatrix%d);\n", matrixCount);

#endif

    }

void CTLVRenderer::DvgMultMatrixL()

    {

    VGfloat matrix[9];

    for (int i = 0; i < 9; i++)

        {

        matrix[i] = iNVGIconData->ReadReal32L();

        }

    vgMultMatrix(matrix);

#ifdef NVG_DEBUG

    int matrixCount = clock() % 1000;

    NVG_DEBUGP2("VGfloat mlMatrix%d[] = {", ++matrixCount);

    NVG_DEBUGP1("VGfloat matrix[] = {");

    NVG_DEBUGP4("    %f, %f, %f, ", matrix[0], matrix[1], matrix[2]);

    NVG_DEBUGP4("    %f, %f, %f, ", matrix[3], matrix[4], matrix[5]);

    NVG_DEBUGP4("    %f, %f, %f};\n", matrix[6], matrix[7], matrix[8]);

    NVG_DEBUGP2("vgMultMatrix(mlMatrix%d);\n", matrixCount);

#endif

    }

void CTLVRenderer::DvgLoadIdentityL()

    {

    if (vgGeti(VG_MATRIX_MODE) == (VGint)VG_MATRIX_IMAGE_USER_TO_SURFACE)

        {

        vgLoadIdentity();

        }

    NVG_DEBUGP1("vgLoadIdentity();\n");

    }

void CTLVRenderer::DvgScaleL()

    {

    VGfloat sx = iNVGIconData->ReadReal32L();

    VGfloat sy = iNVGIconData->ReadReal32L();

    vgScale(sx, sy);

    NVG_DEBUGP3("vgScale(%f, %f);\n", sx, sy);

    }

void CTLVRenderer::DvgTranslateL()

    {

    VGfloat tx = iNVGIconData->ReadReal32L();

    VGfloat ty = iNVGIconData->ReadReal32L();

    vgTranslate(tx, ty);

    NVG_DEBUGP3("vgTranslate(%f, %f);\n", tx, ty);

    }

void CTLVRenderer::DvgAppendPathDataL()

    {

    TUint16         numSegments;

    TUint16         coordinatecount;

    VGubyte *       pathSegments;

    VGubyte *       segmenthandle;

    TFloatFixPt *   pathData;

    TFloatFixPt *   coordhandle;

    iNVGIconData->ReadInt32L();

    numSegments = iNVGIconData->ReadInt16L();

    pathSegments = new (ELeave) VGubyte[numSegments];

    CleanupStack::PushL(TCleanupItem(CleanupArray, pathSegments));

    segmenthandle = pathSegments;

    for(int j=0;j<numSegments;j++, segmenthandle++)

        {

        *segmenthandle = iNVGIconData->ReadInt8L();

        }

    coordinatecount = iNVGIconData->ReadInt16L();

    pathData = new (ELeave) TFloatFixPt[coordinatecount];

    CleanupStack::PushL(TCleanupItem(CleanupTFloatFixArray, pathData));

    TInt lFloatFixVal = 0;

    coordhandle= pathData;

    for(int i=0;i<coordinatecount;i++, coordhandle++)

        {

        lFloatFixVal = iNVGIconData->ReadInt32L();

        coordhandle->copyfloatfix(lFloatFixVal);

        }

    vgAppendPathData(iPathHandle, numSegments, pathSegments, pathData);

    NVG_DEBUGP3("vgAppendPathData((VGPath)%d, (SENGMENTS)%d);\n", iPathHandle, numSegments);

    CleanupStack::PopAndDestroy();

    CleanupStack::PopAndDestroy();

    }

void CTLVRenderer::DvgDrawPathL()

    {

    TUint16 value;

    iNVGIconData->ReadInt32L();

    value = iNVGIconData->ReadInt16L();

    vgDrawPath(iPathHandle, value);

    vgClearPath(iPathHandle, VG_PATH_CAPABILITY_APPEND_TO);

    NVG_DEBUGSTMT(LogvgDrawPath(iPathHandle, value));

    }

void CTLVRenderer::DvgClearPathL()

    {

    TUint16 value;

    iNVGIconData->ReadInt32L();

    value = iNVGIconData->ReadInt16L();

    vgClearPath(iPathHandle, value);

    NVG_DEBUGP1("vgClearPath();\n");

    }

void CTLVRenderer::DvgCreatePaintL()

    {

    TUint  encodedHandle = iNVGIconData->ReadInt32L();

    VGPaint paintH = VGCREATEPAINT();

    if (paintH == VG_INVALID_HANDLE)

        {

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

        }

    TInt error = iTLVVGHandleList.Append(TLVVGHandlePair(paintH, encodedHandle, TLVVGHandlePair::EVGPAINT));

    if (error != KErrNone)

        {

        VGDESTROYPAINT(paintH);

        User::Leave(error);