// Copyright (c) 2010 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:

// 

#ifdef WIN32

#define WIN32_LEAN_AND_MEAN                       // Exclude rarely-used stuff from Windows headers

#include <windows.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <vg/openvg.h>

#include <EGL/egl.h>

#include "KhronosAPIWrapper.h"

#include "serializedfunctioncall.h"

#include "remotefunctioncall.h"

#include "openvgrfc.h"

#include "graphicsvhwcallback.h"        //callback interface Wrapper=>Virtual HW

#include "serialisedapiuids.h"

#include "openvgapiwrapper.h"

#include "khronosapiwrapperdefs.h"

#include "driverapiwrapper.h" //For calling the sync functions

int OpenVGAPIWrapper::vgePathCoordsSizeInBytes()

{

    VGPath dstPath;

    m_currentFunctionCall.GetParamValue( dstPath, 0 );

    VGint startIndex;

    m_currentFunctionCall.GetParamValue( startIndex, 1 );

    VGint numSegments;

    m_currentFunctionCall.GetParamValue( numSegments, 2 );

    if ( !vgePathCoordsSizeInBytesPtr )

        {

        vgePathCoordsSizeInBytesPtr = (vgePathCoordsSizeInBytesPtrType)::eglGetProcAddress("vgePathCoordsSizeInBytes");

        }

	if ( vgePathCoordsSizeInBytesPtr )

	{

		VGint ret = vgePathCoordsSizeInBytesPtr( dstPath, startIndex, numSegments );

		m_currentFunctionCall.SetReturnValue( (TUint32)ret );

	}

	else

	{

		m_currentFunctionCall.SetReturnValue( (TUint32)(-1) );

	}

    return WriteReply();

}

int OpenVGAPIWrapper::vgCreatePaint()

{

    VGPaint paint = ::vgCreatePaint();

    m_currentFunctionCall.SetReturnValue((TUint32)paint);

    return WriteReply();

}

int OpenVGAPIWrapper::vgDestroyPaint()

{

    VGPaint paint;

    m_currentFunctionCall.GetParamValue( paint, 0 );

    ::vgDestroyPaint( paint );

    return WriteReply();

}

int OpenVGAPIWrapper::vgSetPaint()

{

    VGPaint paint;

    m_currentFunctionCall.GetParamValue( paint, 0 );

    VGbitfield paintModes;

    m_currentFunctionCall.GetParamValue( paintModes, 1 );

    ::vgSetPaint(paint, paintModes);

    return WriteReply();

}

int OpenVGAPIWrapper::vgSetParameteri()

{

    VGHandle object;

    m_currentFunctionCall.GetParamValue( object, 0 );

    VGint paramType;

    m_currentFunctionCall.GetParamValue( paramType, 1 );

    VGint value;

    m_currentFunctionCall.GetParamValue( value, 2 );

    ::vgSetParameteri(object, paramType, value);

    return WriteReply();

}

int OpenVGAPIWrapper::vgSetParameterf()

{

    VGHandle object;

    m_currentFunctionCall.GetParamValue( object, 0 );

    VGint paramType;

    m_currentFunctionCall.GetParamValue( paramType, 1 );

    VGfloat value;

    m_currentFunctionCall.GetParamValue( value, 2 );

    ::vgSetParameterf(object, paramType, value);

    return WriteReply();

}

int OpenVGAPIWrapper::vgSetParameterfv()

{

    VGHandle object;

    m_currentFunctionCall.GetParamValue( object, 0 );

    VGint paramType;

    m_currentFunctionCall.GetParamValue( paramType, 1 );

    VGint count;

    m_currentFunctionCall.GetParamValue( count, 2 );

    VGfloat * values;

    TInt size;

    m_currentFunctionCall.GetVectorData( values, size, 3 );

    ::vgSetParameterfv(object, paramType, count, values);

    return WriteReply();

}

int OpenVGAPIWrapper::vgCreatePath()

{

    VGint pathFormat;

    m_currentFunctionCall.GetParamValue( pathFormat, 0 );

    VGPathDatatype datatype;

    m_currentFunctionCall.GetParamValue( datatype, 1 );

    VGfloat scale;

    m_currentFunctionCall.GetParamValue( scale, 2 );

    VGfloat bias;

    m_currentFunctionCall.GetParamValue( bias, 3 );

    VGint segmentCapacityHint;

    m_currentFunctionCall.GetParamValue( segmentCapacityHint, 4 );

    VGint coordCapacityHint;

    m_currentFunctionCall.GetParamValue( coordCapacityHint, 5 );

    VGbitfield capabilities;

    m_currentFunctionCall.GetParamValue( capabilities, 6 );

    VGPath path = ::vgCreatePath( pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);

    m_currentFunctionCall.SetReturnValue((TUint32)path);

    return WriteReply();

}

int OpenVGAPIWrapper::vgDrawPath()

{

    VGPath path;

    m_currentFunctionCall.GetParamValue( path, 0 );

    VGbitfield paintModes;

    m_currentFunctionCall.GetParamValue( paintModes, 1 );

    ::vgDrawPath( path, paintModes );

    return WriteReply();

}

int OpenVGAPIWrapper::vgDestroyPath()

{

    VGPath path;

    m_currentFunctionCall.GetParamValue( path, 0 );

    ::vgDestroyPath(path);

    return WriteReply();

}

int OpenVGAPIWrapper::vgAppendPathData()

{

    VGPath dstPath;

    m_currentFunctionCall.GetParamValue( dstPath, 0 );

    VGint numSegments;

    m_currentFunctionCall.GetParamValue( numSegments, 1 );

    VGubyte * pathSegments;

    TInt size;

    m_currentFunctionCall.GetVectorData( pathSegments, size, 2 );

    void * pathData;

    m_currentFunctionCall.GetVectorData( pathData, size, 3 );

    ::vgAppendPathData( dstPath, numSegments, pathSegments, pathData );

    return WriteReply();

}

int OpenVGAPIWrapper::vgGetError()

{

    VGErrorCode error = ::vgGetError();

    m_currentFunctionCall.SetReturnValue((TUint32)error);

    return WriteReply();

}

int OpenVGAPIWrapper::vgSeti()

{

    VGParamType type;

    m_currentFunctionCall.GetParamValue( type, 0 );

    VGint value;

    m_currentFunctionCall.GetParamValue( value, 1 );

    ::vgSeti( type, value);

    return WriteReply();

}

int OpenVGAPIWrapper::vgSetf()

{

    VGParamType type;

    m_currentFunctionCall.GetParamValue( type, 0 );

    VGfloat value;

    m_currentFunctionCall.GetParamValue( value, 1 );

    ::vgSetf( type, value );

    return WriteReply();

}

int OpenVGAPIWrapper::vgSetfv()

{

    VGParamType type;

    m_currentFunctionCall.GetParamValue( type, 0 );

    VGint count;

    m_currentFunctionCall.GetParamValue( count, 1 );

    VGfloat * values;

    TInt size;

    m_currentFunctionCall.GetVectorData( values, size, 2 );

    ::vgSetfv( type, count, values);

    return WriteReply();

}

int OpenVGAPIWrapper::vgClear()

{

    VGint x;

    m_currentFunctionCall.GetParamValue( x, 0 );

    VGint y;

    m_currentFunctionCall.GetParamValue( y, 1 );

    VGint width;

    m_currentFunctionCall.GetParamValue( width, 2 );

    VGint height;

    m_currentFunctionCall.GetParamValue( height, 3 );

    ::vgClear( x, y, width, height );

    return WriteReply();

}

int OpenVGAPIWrapper::vgLoadIdentity()

{

    ::vgLoadIdentity();

    return WriteReply();

}

int OpenVGAPIWrapper::vgRotate()

{

    VGfloat angle;

    m_currentFunctionCall.GetParamValue( angle, 0 );

    ::vgRotate( angle );

    return WriteReply();

}

int OpenVGAPIWrapper::vgScale()

{

    VGfloat sx;

    m_currentFunctionCall.GetParamValue( sx, 0 );

    VGfloat sy;

    m_currentFunctionCall.GetParamValue( sy, 1 );

    ::vgScale( sx, sy );

    return WriteReply();

}

int OpenVGAPIWrapper::vgTranslate()

{

    VGfloat tx;

    m_currentFunctionCall.GetParamValue( tx, 0 );

    VGfloat ty;

    m_currentFunctionCall.GetParamValue( ty, 1 );

    ::vgTranslate( tx, ty );

    return WriteReply();

}

int OpenVGAPIWrapper::vgReadPixels()

{

    VGint dataStride;

    m_currentFunctionCall.GetParamValue( dataStride, 1 );

    VGImageFormat dataFormat;

    m_currentFunctionCall.GetParamValue( dataFormat, 2 );

    VGint sx;

    m_currentFunctionCall.GetParamValue( sx, 3 );

    VGint sy;

    m_currentFunctionCall.GetParamValue( sy, 4 );

    VGint width;

    m_currentFunctionCall.GetParamValue( width, 5 );

    VGint height;

    m_currentFunctionCall.GetParamValue( height, 6 );

	VGint pixmapSize;

	m_currentFunctionCall.GetParamValue(pixmapSize, 7);

    void *dataBuffer = iStack->AllocFromStack(pixmapSize, 4);

    ::vgReadPixels( dataBuffer, dataStride, dataFormat, sx, sy, width, height );

    m_currentFunctionCall.SetVectorData( dataBuffer, pixmapSize, 0 );

    int ret = WriteReply();

    iStack->ClearStack();

    dataBuffer = NULL;

    return ret;

}

int OpenVGAPIWrapper::vgFlush()

{

    ::vgFlush();

    return WriteReply();

}

int OpenVGAPIWrapper::vgFinish()

{

    ::vgFinish();

    return WriteReply();

}

int OpenVGAPIWrapper::vgSetiv()

{

    VGParamType type;

    m_currentFunctionCall.GetParamValue( type, 0 );

    VGint count;

    m_currentFunctionCall.GetParamValue( count, 1 );

    VGint * values;

    TInt size;

    m_currentFunctionCall.GetVectorData( values, size, 2 );

    ::vgSetiv( type, count, values);

    return WriteReply();

}

int OpenVGAPIWrapper::vgGetf()

{

    VGParamType type;

    m_currentFunctionCall.GetParamValue( type, 0 );

    VGfloat ret = ::vgGetf( type );

    m_currentFunctionCall.SetReturnValue( (TUint32)ret );

    return WriteReply();

}

int OpenVGAPIWrapper::vgGeti()

{

    VGParamType type;

    m_currentFunctionCall.GetParamValue( type, 0 );

    VGint ret = ::vgGeti( type );

    m_currentFunctionCall.SetReturnValue( (TUint32)ret );

    return WriteReply();

}

int OpenVGAPIWrapper::vgGetVectorSize()

{

    VGParamType type;

    m_currentFunctionCall.GetParamValue( type, 0 );

    VGint ret = ::vgGetVectorSize( type );

    m_currentFunctionCall.SetReturnValue( (TUint32)ret );

    return WriteReply();

}

int OpenVGAPIWrapper::vgGetParameterf()

{

    VGHandle object;

    m_currentFunctionCall.GetParamValue( object, 0 );

    VGint paramType;

    m_currentFunctionCall.GetParamValue( paramType, 1 );

    VGfloat ret = ::vgGetParameterf( object, paramType );

    m_currentFunctionCall.SetReturnValue( (TUint32)ret );

    return WriteReply();

}

int OpenVGAPIWrapper::vgGetParameteri()

{

    VGHandle object;

    m_currentFunctionCall.GetParamValue( object, 0 );

    VGint paramType;

    m_currentFunctionCall.GetParamValue( paramType, 1 );

    VGint ret = ::vgGetParameteri( object, paramType );

    m_currentFunctionCall.SetReturnValue( (TUint32)ret );

    return WriteReply();

}

int OpenVGAPIWrapper::vgGetParameterVectorSize()

{

    VGHandle object;

    m_currentFunctionCall.GetParamValue( object, 0 );

    VGint paramType;

    m_currentFunctionCall.GetParamValue( paramType, 1 );

    VGint ret = ::vgGetParameterVectorSize( object, paramType );

    m_currentFunctionCall.SetReturnValue( (TUint32)ret );

    return WriteReply();

}

int OpenVGAPIWrapper::vgShear()

{

    VGfloat shx;

    m_currentFunctionCall.GetParamValue( shx, 0 );

    VGfloat shy;

    m_currentFunctionCall.GetParamValue( shy, 1 );

    ::vgShear( shx, shy );

    return WriteReply();

}

int OpenVGAPIWrapper::vgMask()

{

    VGHandle mask;

    m_currentFunctionCall.GetParamValue( mask, 0 );

    VGMaskOperation operation;

    m_currentFunctionCall.GetParamValue( operation, 1 );

    VGint x;

    m_currentFunctionCall.GetParamValue( x, 2 );

    VGint y;

    m_currentFunctionCall.GetParamValue( y, 3 );

    VGint width;

    m_currentFunctionCall.GetParamValue( width, 4 );

    VGint height;

    m_currentFunctionCall.GetParamValue( height, 5 );

    ::vgMask( mask, operation, x, y, width, height );

    return WriteReply();

}

int OpenVGAPIWrapper::vgRenderToMask()

{

    VGPath path;

    m_currentFunctionCall.GetParamValue( path, 0 );

    VGbitfield paintModes;

    m_currentFunctionCall.GetParamValue( paintModes, 1 );

    VGMaskOperation operation;

    m_currentFunctionCall.GetParamValue( operation, 2 );

    ::vgRenderToMask( path, paintModes, operation);

    return WriteReply();

}

int OpenVGAPIWrapper::vgCreateMaskLayer()

{

    VGint width;

    m_currentFunctionCall.GetParamValue( width, 0 );

    VGint height;

    m_currentFunctionCall.GetParamValue( height, 1 );

    ::vgCreateMaskLayer( width, height );

    return WriteReply();

}

int OpenVGAPIWrapper::vgDestroyMaskLayer()

{

    VGMaskLayer maskLayer;

    m_currentFunctionCall.GetParamValue( maskLayer, 0 );

    ::vgDestroyMaskLayer( maskLayer );

    return WriteReply();

}

int OpenVGAPIWrapper::vgFillMaskLayer()

{

    VGMaskLayer maskLayer;

    m_currentFunctionCall.GetParamValue( maskLayer, 0 );

    VGint x;

    m_currentFunctionCall.GetParamValue( x, 1 );

    VGint y;

    m_currentFunctionCall.GetParamValue( y, 2 );

    VGint width;

    m_currentFunctionCall.GetParamValue( width, 3 );

    VGint height;

    m_currentFunctionCall.GetParamValue( height, 4 );

    VGfloat value;

    m_currentFunctionCall.GetParamValue( value, 5 );

    ::vgFillMaskLayer( maskLayer, x, y,

        width, height, value );

    return WriteReply();

}

int OpenVGAPIWrapper::vgCopyMask()

{

    VGMaskLayer maskLayer;

    m_currentFunctionCall.GetParamValue( maskLayer, 0 );

    VGint sx;

    m_currentFunctionCall.GetParamValue( sx, 1 );

    VGint sy;

    m_currentFunctionCall.GetParamValue( sy, 2 );

    VGint dx;

    m_currentFunctionCall.GetParamValue( dx, 3 );

    VGint dy;

    m_currentFunctionCall.GetParamValue( dy, 4 );

    VGint width;

    m_currentFunctionCall.GetParamValue( width, 5 );

    VGint height;

    m_currentFunctionCall.GetParamValue( height, 6 );

    ::vgCopyMask( maskLayer, sx, sy, dx, dy,

        width, height );

    return WriteReply();

}

int OpenVGAPIWrapper::vgClearPath()

{