1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // 

    15 

    16 #ifdef WIN32

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

    18 #include <windows.h>

    19 #endif

    20 

    21 #include <stdio.h>

    22 #include <stdlib.h>

    23 #include <vg/openvg.h>

    24 #include <EGL/egl.h>

    25 #include "KhronosAPIWrapper.h"

    26 #include "serializedfunctioncall.h"

    27 #include "remotefunctioncall.h"

    28 #include "openvgrfc.h"

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

    30 #include "serialisedapiuids.h"

    31 #include "openvgapiwrapper.h"

    32 #include "khronosapiwrapperdefs.h"

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

    34 

    35 int OpenVGAPIWrapper::vgePathCoordsSizeInBytes()

    36 {

    37     VGPath dstPath;

    38     m_currentFunctionCall.GetParamValue( dstPath, 0 );

    39     VGint startIndex;

    40     m_currentFunctionCall.GetParamValue( startIndex, 1 );

    41     VGint numSegments;

    42     m_currentFunctionCall.GetParamValue( numSegments, 2 );

    43     if ( !vgePathCoordsSizeInBytesPtr )

    44         {

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

    46         }

    47 	if ( vgePathCoordsSizeInBytesPtr )

    48 	{

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

    50 		m_currentFunctionCall.SetReturnValue( (TUint32)ret );

    51 	}

    52 	else

    53 	{

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

    55 	}

    56 

    57     return WriteReply();

    58 }

    59 

    60 int OpenVGAPIWrapper::vgCreatePaint()

    61 {

    62     VGPaint paint = ::vgCreatePaint();

    63     m_currentFunctionCall.SetReturnValue((TUint32)paint);

    64     return WriteReply();

    65 }

    66 

    67 

    68 int OpenVGAPIWrapper::vgDestroyPaint()

    69 {

    70     VGPaint paint;

    71     m_currentFunctionCall.GetParamValue( paint, 0 );

    72     ::vgDestroyPaint( paint );

    73     return WriteReply();

    74 }

    75 

    76 

    77 int OpenVGAPIWrapper::vgSetPaint()

    78 {

    79     VGPaint paint;

    80     m_currentFunctionCall.GetParamValue( paint, 0 );

    81     VGbitfield paintModes;

    82     m_currentFunctionCall.GetParamValue( paintModes, 1 );

    83     ::vgSetPaint(paint, paintModes);

    84     return WriteReply();

    85 }

    86 

    87 

    88 int OpenVGAPIWrapper::vgSetParameteri()

    89 {

    90     VGHandle object;

    91     m_currentFunctionCall.GetParamValue( object, 0 );

    92     VGint paramType;

    93     m_currentFunctionCall.GetParamValue( paramType, 1 );

    94     VGint value;

    95     m_currentFunctionCall.GetParamValue( value, 2 );

    96     ::vgSetParameteri(object, paramType, value);

    97     return WriteReply();

    98 }

    99 

   100 

   101 int OpenVGAPIWrapper::vgSetParameterf()

   102 {

   103     VGHandle object;

   104     m_currentFunctionCall.GetParamValue( object, 0 );

   105     VGint paramType;

   106     m_currentFunctionCall.GetParamValue( paramType, 1 );

   107     VGfloat value;

   108     m_currentFunctionCall.GetParamValue( value, 2 );

   109     ::vgSetParameterf(object, paramType, value);

   110     return WriteReply();

   111 }

   112 

   113 

   114 int OpenVGAPIWrapper::vgSetParameterfv()

   115 {

   116     VGHandle object;

   117     m_currentFunctionCall.GetParamValue( object, 0 );

   118     VGint paramType;

   119     m_currentFunctionCall.GetParamValue( paramType, 1 );

   120     VGint count;

   121     m_currentFunctionCall.GetParamValue( count, 2 );

   122     VGfloat * values;

   123     TInt size;

   124     m_currentFunctionCall.GetVectorData( values, size, 3 );

   125 

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

   127     return WriteReply();

   128 }

   129 

   130 int OpenVGAPIWrapper::vgCreatePath()

   131 {

   132     VGint pathFormat;

   133     m_currentFunctionCall.GetParamValue( pathFormat, 0 );

   134 

   135     VGPathDatatype datatype;

   136     m_currentFunctionCall.GetParamValue( datatype, 1 );

   137 

   138     VGfloat scale;

   139     m_currentFunctionCall.GetParamValue( scale, 2 );

   140 

   141     VGfloat bias;

   142     m_currentFunctionCall.GetParamValue( bias, 3 );

   143 

   144     VGint segmentCapacityHint;

   145     m_currentFunctionCall.GetParamValue( segmentCapacityHint, 4 );

   146 

   147     VGint coordCapacityHint;

   148     m_currentFunctionCall.GetParamValue( coordCapacityHint, 5 );

   149 

   150     VGbitfield capabilities;

   151     m_currentFunctionCall.GetParamValue( capabilities, 6 );

   152 

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

   154     m_currentFunctionCall.SetReturnValue((TUint32)path);

   155     return WriteReply();

   156 

   157 }

   158 

   159 int OpenVGAPIWrapper::vgDrawPath()

   160 {

   161     VGPath path;

   162     m_currentFunctionCall.GetParamValue( path, 0 );

   163 

   164     VGbitfield paintModes;

   165     m_currentFunctionCall.GetParamValue( paintModes, 1 );

   166 

   167     ::vgDrawPath( path, paintModes );

   168     return WriteReply();

   169 }

   170 

   171 int OpenVGAPIWrapper::vgDestroyPath()

   172 {

   173     VGPath path;

   174     m_currentFunctionCall.GetParamValue( path, 0 );

   175 

   176     ::vgDestroyPath(path);

   177     return WriteReply();

   178 }

   179 

   180 

   181 int OpenVGAPIWrapper::vgAppendPathData()

   182 {

   183     VGPath dstPath;

   184     m_currentFunctionCall.GetParamValue( dstPath, 0 );

   185     VGint numSegments;

   186     m_currentFunctionCall.GetParamValue( numSegments, 1 );

   187     VGubyte * pathSegments;

   188     TInt size;

   189     m_currentFunctionCall.GetVectorData( pathSegments, size, 2 );

   190 

   191     void * pathData;

   192     m_currentFunctionCall.GetVectorData( pathData, size, 3 );

   193 

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

   195     return WriteReply();

   196 }

   197 

   198 

   199 int OpenVGAPIWrapper::vgGetError()

   200 {

   201     VGErrorCode error = ::vgGetError();

   202     m_currentFunctionCall.SetReturnValue((TUint32)error);

   203     return WriteReply();

   204 }

   205 

   206 

   207 int OpenVGAPIWrapper::vgSeti()

   208 {

   209     VGParamType type;

   210     m_currentFunctionCall.GetParamValue( type, 0 );

   211     VGint value;

   212     m_currentFunctionCall.GetParamValue( value, 1 );

   213     ::vgSeti( type, value);

   214     return WriteReply();

   215 }

   216 

   217 

   218 int OpenVGAPIWrapper::vgSetf()

   219 {

   220     VGParamType type;

   221     m_currentFunctionCall.GetParamValue( type, 0 );

   222     VGfloat value;

   223     m_currentFunctionCall.GetParamValue( value, 1 );

   224     ::vgSetf( type, value );

   225     return WriteReply();

   226 }

   227 

   228 

   229 int OpenVGAPIWrapper::vgSetfv()

   230 {

   231     VGParamType type;

   232     m_currentFunctionCall.GetParamValue( type, 0 );

   233     VGint count;

   234     m_currentFunctionCall.GetParamValue( count, 1 );

   235     VGfloat * values;

   236     TInt size;

   237     m_currentFunctionCall.GetVectorData( values, size, 2 );

   238     ::vgSetfv( type, count, values);

   239     return WriteReply();

   240 }

   241 

   242 

   243 int OpenVGAPIWrapper::vgClear()

   244 {

   245     VGint x;

   246     m_currentFunctionCall.GetParamValue( x, 0 );

   247     VGint y;

   248     m_currentFunctionCall.GetParamValue( y, 1 );

   249     VGint width;

   250     m_currentFunctionCall.GetParamValue( width, 2 );

   251     VGint height;

   252     m_currentFunctionCall.GetParamValue( height, 3 );

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

   254     return WriteReply();

   255 }

   256 

   257 

   258 int OpenVGAPIWrapper::vgLoadIdentity()

   259 {

   260     ::vgLoadIdentity();

   261     return WriteReply();

   262 }

   263 

   264 

   265 int OpenVGAPIWrapper::vgRotate()

   266 {

   267     VGfloat angle;

   268     m_currentFunctionCall.GetParamValue( angle, 0 );

   269     ::vgRotate( angle );

   270     return WriteReply();

   271 }

   272 

   273 

   274 int OpenVGAPIWrapper::vgScale()

   275 {

   276     VGfloat sx;

   277     m_currentFunctionCall.GetParamValue( sx, 0 );

   278     VGfloat sy;

   279     m_currentFunctionCall.GetParamValue( sy, 1 );

   280     ::vgScale( sx, sy );

   281     return WriteReply();

   282 }

   283 

   284 

   285 int OpenVGAPIWrapper::vgTranslate()

   286 {

   287     VGfloat tx;

   288     m_currentFunctionCall.GetParamValue( tx, 0 );

   289     VGfloat ty;

   290     m_currentFunctionCall.GetParamValue( ty, 1 );

   291     ::vgTranslate( tx, ty );

   292     return WriteReply();

   293 }

   294 

   295 

   296 int OpenVGAPIWrapper::vgReadPixels()

   297 {

   298     VGint dataStride;

   299     m_currentFunctionCall.GetParamValue( dataStride, 1 );

   300     VGImageFormat dataFormat;

   301     m_currentFunctionCall.GetParamValue( dataFormat, 2 );

   302     VGint sx;

   303     m_currentFunctionCall.GetParamValue( sx, 3 );

   304     VGint sy;

   305     m_currentFunctionCall.GetParamValue( sy, 4 );

   306     VGint width;

   307     m_currentFunctionCall.GetParamValue( width, 5 );

   308     VGint height;

   309     m_currentFunctionCall.GetParamValue( height, 6 );

   310 	VGint pixmapSize;

   311 	m_currentFunctionCall.GetParamValue(pixmapSize, 7);

   312 

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

   314 

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

   316     m_currentFunctionCall.SetVectorData( dataBuffer, pixmapSize, 0 );

   317     int ret = WriteReply();

   318     iStack->ClearStack();

   319     dataBuffer = NULL;

   320     return ret;

   321 }

   322 

   323 

   324 int OpenVGAPIWrapper::vgFlush()

   325 {

   326     ::vgFlush();

   327     return WriteReply();

   328 }

   329 

   330 

   331 int OpenVGAPIWrapper::vgFinish()

   332 {

   333     ::vgFinish();

   334     return WriteReply();

   335 }

   336 

   337 

   338 int OpenVGAPIWrapper::vgSetiv()

   339 {

   340     VGParamType type;

   341     m_currentFunctionCall.GetParamValue( type, 0 );

   342     VGint count;

   343     m_currentFunctionCall.GetParamValue( count, 1 );

   344     VGint * values;

   345     TInt size;

   346     m_currentFunctionCall.GetVectorData( values, size, 2 );

   347     ::vgSetiv( type, count, values);

   348     return WriteReply();

   349 }

   350 

   351 

   352 int OpenVGAPIWrapper::vgGetf()

   353 {

   354     VGParamType type;

   355     m_currentFunctionCall.GetParamValue( type, 0 );

   356     VGfloat ret = ::vgGetf( type );

   357     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   358     return WriteReply();

   359 }

   360 

   361 

   362 int OpenVGAPIWrapper::vgGeti()

   363 {

   364     VGParamType type;

   365     m_currentFunctionCall.GetParamValue( type, 0 );

   366     VGint ret = ::vgGeti( type );

   367     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   368     return WriteReply();

   369 }

   370 

   371 

   372 int OpenVGAPIWrapper::vgGetVectorSize()

   373 {

   374     VGParamType type;

   375     m_currentFunctionCall.GetParamValue( type, 0 );

   376     VGint ret = ::vgGetVectorSize( type );

   377     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   378     return WriteReply();

   379 }

   380 

   381 

   382 int OpenVGAPIWrapper::vgGetParameterf()

   383 {

   384     VGHandle object;

   385     m_currentFunctionCall.GetParamValue( object, 0 );

   386     VGint paramType;

   387     m_currentFunctionCall.GetParamValue( paramType, 1 );

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

   389     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   390     return WriteReply();

   391 }

   392 

   393 

   394 int OpenVGAPIWrapper::vgGetParameteri()

   395 {

   396     VGHandle object;

   397     m_currentFunctionCall.GetParamValue( object, 0 );

   398     VGint paramType;

   399     m_currentFunctionCall.GetParamValue( paramType, 1 );

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

   401     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   402     return WriteReply();

   403 }

   404 

   405 

   406 int OpenVGAPIWrapper::vgGetParameterVectorSize()

   407 {

   408     VGHandle object;

   409     m_currentFunctionCall.GetParamValue( object, 0 );

   410     VGint paramType;

   411     m_currentFunctionCall.GetParamValue( paramType, 1 );

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

   413     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   414     return WriteReply();

   415 }

   416 

   417 

   418 int OpenVGAPIWrapper::vgShear()

   419 {

   420     VGfloat shx;

   421     m_currentFunctionCall.GetParamValue( shx, 0 );

   422     VGfloat shy;

   423     m_currentFunctionCall.GetParamValue( shy, 1 );

   424     ::vgShear( shx, shy );

   425     return WriteReply();

   426 }

   427 

   428 

   429 int OpenVGAPIWrapper::vgMask()

   430 {

   431     VGHandle mask;

   432     m_currentFunctionCall.GetParamValue( mask, 0 );

   433     VGMaskOperation operation;

   434     m_currentFunctionCall.GetParamValue( operation, 1 );

   435     VGint x;

   436     m_currentFunctionCall.GetParamValue( x, 2 );

   437     VGint y;

   438     m_currentFunctionCall.GetParamValue( y, 3 );

   439     VGint width;

   440     m_currentFunctionCall.GetParamValue( width, 4 );

   441     VGint height;

   442     m_currentFunctionCall.GetParamValue( height, 5 );

   443 

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

   445     return WriteReply();

   446 }

   447 

   448 

   449 int OpenVGAPIWrapper::vgRenderToMask()

   450 {

   451     VGPath path;

   452     m_currentFunctionCall.GetParamValue( path, 0 );

   453     VGbitfield paintModes;

   454     m_currentFunctionCall.GetParamValue( paintModes, 1 );

   455     VGMaskOperation operation;

   456     m_currentFunctionCall.GetParamValue( operation, 2 );

   457 

   458     ::vgRenderToMask( path, paintModes, operation);

   459     return WriteReply();

   460 }

   461 

   462 

   463 int OpenVGAPIWrapper::vgCreateMaskLayer()

   464 {

   465     VGint width;

   466     m_currentFunctionCall.GetParamValue( width, 0 );

   467     VGint height;

   468     m_currentFunctionCall.GetParamValue( height, 1 );

   469     ::vgCreateMaskLayer( width, height );

   470     return WriteReply();

   471 }

   472 

   473 

   474 int OpenVGAPIWrapper::vgDestroyMaskLayer()

   475 {

   476     VGMaskLayer maskLayer;

   477     m_currentFunctionCall.GetParamValue( maskLayer, 0 );

   478     ::vgDestroyMaskLayer( maskLayer );

   479     return WriteReply();

   480 }

   481 

   482 

   483 int OpenVGAPIWrapper::vgFillMaskLayer()

   484 {

   485     VGMaskLayer maskLayer;

   486     m_currentFunctionCall.GetParamValue( maskLayer, 0 );

   487     VGint x;

   488     m_currentFunctionCall.GetParamValue( x, 1 );

   489     VGint y;

   490     m_currentFunctionCall.GetParamValue( y, 2 );

   491     VGint width;

   492     m_currentFunctionCall.GetParamValue( width, 3 );

   493     VGint height;

   494     m_currentFunctionCall.GetParamValue( height, 4 );

   495     VGfloat value;

   496     m_currentFunctionCall.GetParamValue( value, 5 );

   497 

   498     ::vgFillMaskLayer( maskLayer, x, y,

   499         width, height, value );

   500     return WriteReply();

   501 }

   502 

   503 

   504 int OpenVGAPIWrapper::vgCopyMask()

   505 {

   506     VGMaskLayer maskLayer;

   507     m_currentFunctionCall.GetParamValue( maskLayer, 0 );

   508     VGint sx;

   509     m_currentFunctionCall.GetParamValue( sx, 1 );

   510     VGint sy;

   511     m_currentFunctionCall.GetParamValue( sy, 2 );

   512     VGint dx;

   513     m_currentFunctionCall.GetParamValue( dx, 3 );

   514     VGint dy;

   515     m_currentFunctionCall.GetParamValue( dy, 4 );

   516     VGint width;

   517     m_currentFunctionCall.GetParamValue( width, 5 );

   518     VGint height;

   519     m_currentFunctionCall.GetParamValue( height, 6 );

   520 

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

   522         width, height );

   523     return WriteReply();

   524 }

   525 

   526 

   527 int OpenVGAPIWrapper::vgClearPath()

   528 {

   529     VGPath path;

   530     m_currentFunctionCall.GetParamValue( path, 0 );

   531     VGbitfield capabilities;

   532     m_currentFunctionCall.GetParamValue( capabilities, 1 );

   533 

   534     ::vgClearPath( path, capabilities );

   535     return WriteReply();

   536 }

   537 

   538 

   539 int OpenVGAPIWrapper::vgRemovePathCapabilities()

   540 {

   541     VGPath path;

   542     m_currentFunctionCall.GetParamValue( path, 0 );

   543     VGbitfield capabilities;

   544     m_currentFunctionCall.GetParamValue( capabilities, 1 );

   545     ::vgRemovePathCapabilities( path, capabilities );

   546     return WriteReply();

   547 }

   548 

   549 

   550 int OpenVGAPIWrapper::vgGetPathCapabilities()

   551 {

   552     VGPath path;

   553     m_currentFunctionCall.GetParamValue( path, 0 );

   554     VGbitfield ret = ::vgGetPathCapabilities( path );

   555     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   556     return WriteReply();

   557 }

   558 

   559 

   560 int OpenVGAPIWrapper::vgAppendPath()

   561 {

   562     VGPath dstPath;

   563     m_currentFunctionCall.GetParamValue( dstPath, 0 );

   564     VGPath srcPath;

   565     m_currentFunctionCall.GetParamValue( srcPath, 1 );

   566     ::vgAppendPath( dstPath, srcPath );

   567     return WriteReply();

   568 }

   569 

   570 

   571 int OpenVGAPIWrapper::vgTransformPath()

   572 {

   573     VGPath dstPath;

   574     m_currentFunctionCall.GetParamValue( dstPath, 0 );

   575     VGPath srcPath;

   576     m_currentFunctionCall.GetParamValue( srcPath, 1 );

   577     ::vgTransformPath( dstPath, srcPath );

   578     return WriteReply();

   579 }

   580 

   581 

   582 int OpenVGAPIWrapper::vgInterpolatePath()

   583 {

   584     VGPath dstPath;

   585     m_currentFunctionCall.GetParamValue( dstPath, 0 );

   586     VGPath startPath;

   587     m_currentFunctionCall.GetParamValue( startPath, 1 );

   588     VGPath endPath;

   589     m_currentFunctionCall.GetParamValue( endPath, 2 );

   590     VGfloat amount;

   591     m_currentFunctionCall.GetParamValue( amount, 3 );

   592 

   593     ::vgInterpolatePath( dstPath, startPath, endPath, amount );

   594     return WriteReply();

   595 }

   596 

   597 

   598 int OpenVGAPIWrapper::vgPathLength()

   599 {

   600     VGPath path;

   601     m_currentFunctionCall.GetParamValue( path, 0 );

   602     VGint startSegment;

   603     m_currentFunctionCall.GetParamValue( startSegment, 1 );

   604     VGint numSegments;

   605     m_currentFunctionCall.GetParamValue( numSegments, 2 );

   606 

   607     VGfloat ret = ::vgPathLength( path, startSegment, numSegments );

   608     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   609     return WriteReply();

   610 }

   611 

   612 

   613 int OpenVGAPIWrapper::vgGetPaint()

   614 {

   615     VGPaintMode paintMode;

   616     m_currentFunctionCall.GetParamValue( paintMode, 0 );

   617     VGPaint ret = ::vgGetPaint( paintMode );

   618     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   619     return WriteReply();

   620 }

   621 

   622 

   623 int OpenVGAPIWrapper::vgSetColor()

   624 {

   625     VGPaint paint;

   626     m_currentFunctionCall.GetParamValue( paint, 0 );

   627     VGuint rgba;

   628     m_currentFunctionCall.GetParamValue( rgba, 1 );

   629 

   630     ::vgSetColor( paint, rgba );

   631     return WriteReply();

   632 }

   633 

   634 

   635 int OpenVGAPIWrapper::vgGetColor()

   636 {

   637     VGPaint paint;

   638     m_currentFunctionCall.GetParamValue( paint, 0 );

   639     VGuint ret = ::vgGetColor( paint );

   640     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   641     return WriteReply();

   642 }

   643 

   644 

   645 int OpenVGAPIWrapper::vgPaintPattern()

   646 {

   647     VGPaint paint;

   648     m_currentFunctionCall.GetParamValue( paint, 0 );

   649     VGImage pattern;

   650     m_currentFunctionCall.GetParamValue( pattern, 1 );

   651 

   652     ::vgPaintPattern( paint, pattern );

   653     return WriteReply();

   654 }

   655 

   656 

   657 int OpenVGAPIWrapper::vgCreateImage()

   658 {

   659     VGImageFormat format;

   660     m_currentFunctionCall.GetParamValue( format, 0 );

   661     VGint width;

   662     m_currentFunctionCall.GetParamValue( width, 1 );

   663     VGint height;

   664     m_currentFunctionCall.GetParamValue( height, 2 );

   665     VGbitfield allowedQuality;

   666     m_currentFunctionCall.GetParamValue( allowedQuality, 3 );

   667 

   668     VGImage ret = ::vgCreateImage( format, width, height, allowedQuality );

   669     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   670     return WriteReply();

   671 }

   672 

   673 

   674 int OpenVGAPIWrapper::vgDestroyImage()

   675 {

   676     VGImage image;

   677     m_currentFunctionCall.GetParamValue( image, 0 );

   678     ::vgDestroyImage( image );

   679     return WriteReply();

   680 }

   681 

   682 

   683 int OpenVGAPIWrapper::vgClearImage()

   684 {

   685     VGImage image;

   686     m_currentFunctionCall.GetParamValue( image, 0 );

   687     VGint x;

   688     m_currentFunctionCall.GetParamValue( x, 1 );

   689     VGint y;

   690     m_currentFunctionCall.GetParamValue( y, 2 );

   691     VGint width;

   692     m_currentFunctionCall.GetParamValue( width, 3 );

   693     VGint height;

   694     m_currentFunctionCall.GetParamValue( height, 4 );

   695 

   696 	doSync( 5, image );

   697 

   698     ::vgClearImage( image, x, y, width, height );

   699     return WriteReply();

   700 }

   701 

   702 

   703 int OpenVGAPIWrapper::vgChildImage()

   704 {

   705     VGImage parent;

   706     m_currentFunctionCall.GetParamValue( parent, 0 );

   707     VGint x;

   708     m_currentFunctionCall.GetParamValue( x, 1 );

   709     VGint y;

   710     m_currentFunctionCall.GetParamValue( y, 2 );

   711     VGint width;

   712     m_currentFunctionCall.GetParamValue( width, 3 );

   713     VGint height;

   714     m_currentFunctionCall.GetParamValue( height, 4 );

   715     VGImage ret = ::vgChildImage( parent, x, y, width, height );

   716     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   717     return WriteReply();

   718 }

   719 

   720 

   721 int OpenVGAPIWrapper::vgGetParent()

   722 {

   723     VGImage image;

   724     m_currentFunctionCall.GetParamValue( image, 0 );

   725     VGImage ret = ::vgGetParent( image );

   726     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   727     return WriteReply();

   728 }

   729 

   730 

   731 int OpenVGAPIWrapper::vgCopyImage()

   732 {

   733     VGImage dst;

   734     m_currentFunctionCall.GetParamValue( dst, 0 );

   735     VGint dx;

   736     m_currentFunctionCall.GetParamValue( dx, 1 );

   737     VGint dy;

   738     m_currentFunctionCall.GetParamValue( dy, 2 );

   739     VGImage src;

   740     m_currentFunctionCall.GetParamValue( src, 3 );

   741     VGint sx;

   742     m_currentFunctionCall.GetParamValue( sx, 4 );

   743     VGint sy;

   744     m_currentFunctionCall.GetParamValue( sy, 5 );

   745     VGint width;

   746     m_currentFunctionCall.GetParamValue( width, 6 );

   747     VGint height;

   748     m_currentFunctionCall.GetParamValue( height, 7 );

   749     VGboolean dither;

   750     m_currentFunctionCall.GetParamValue( dither, 8 );

   751 

   752 	doSync( 9, dst, src );

   753 

   754     ::vgCopyImage( dst, dx, dy, src, sx, sy, width, height, dither );

   755     return WriteReply();

   756 }

   757 

   758 

   759 int OpenVGAPIWrapper::vgDrawImage()

   760 {

   761     VGImage image;

   762     m_currentFunctionCall.GetParamValue( image, 0 );

   763 

   764 

   765     ::vgDrawImage( image );

   766     return WriteReply();

   767 }

   768 

   769 

   770 int OpenVGAPIWrapper::vgSetPixels()

   771 {

   772     VGint dx;

   773     m_currentFunctionCall.GetParamValue( dx, 0 );

   774     VGint dy;

   775     m_currentFunctionCall.GetParamValue( dy, 1 );

   776     VGImage src;

   777     m_currentFunctionCall.GetParamValue( src, 2 );

   778     VGint sx;

   779     m_currentFunctionCall.GetParamValue( sx, 3 );

   780     VGint sy;

   781     m_currentFunctionCall.GetParamValue( sy, 4 );

   782     VGint width;

   783     m_currentFunctionCall.GetParamValue( width, 5 );

   784     VGint height;

   785     m_currentFunctionCall.GetParamValue( height, 6 );

   786 

   787 	doSync( 7, src );

   788 

   789     ::vgSetPixels( dx, dy, src, sx, sy, width, height );

   790     return WriteReply();

   791 }

   792 

   793 

   794 int OpenVGAPIWrapper::vgGetPixels()

   795 {

   796     VGImage dst;

   797     m_currentFunctionCall.GetParamValue( dst, 0 );

   798     VGint dx;

   799     m_currentFunctionCall.GetParamValue( dx, 1 );

   800     VGint dy;

   801     m_currentFunctionCall.GetParamValue( dy, 2 );

   802     VGint sx;

   803     m_currentFunctionCall.GetParamValue( sx, 3 );

   804     VGint sy;

   805     m_currentFunctionCall.GetParamValue( sy, 4 );

   806     VGint width;

   807     m_currentFunctionCall.GetParamValue( width, 5 );

   808     VGint height;

   809     m_currentFunctionCall.GetParamValue( height, 6 );

   810 

   811 	doSync( 7, dst );

   812 

   813     ::vgGetPixels( dst, dx, dy, sx, sy, width, height );

   814     return WriteReply();

   815 }

   816 

   817 

   818 int OpenVGAPIWrapper::vgCopyPixels()

   819 {

   820     VGint dx;

   821     m_currentFunctionCall.GetParamValue( dx, 0 );

   822     VGint dy;

   823     m_currentFunctionCall.GetParamValue( dy, 1 );

   824     VGint sx;

   825     m_currentFunctionCall.GetParamValue( sx, 2 );

   826     VGint sy;

   827     m_currentFunctionCall.GetParamValue( sy, 3 );

   828     VGint width;

   829     m_currentFunctionCall.GetParamValue( width, 4 );

   830     VGint height;

   831     m_currentFunctionCall.GetParamValue( height, 5 );

   832 

   833     ::vgCopyPixels( dx, dy, sx, sy, width, height );

   834     return WriteReply();

   835 }

   836 

   837 

   838 int OpenVGAPIWrapper::vgCreateFont()

   839 {

   840     VGint glyphCapacityHint;

   841     m_currentFunctionCall.GetParamValue( glyphCapacityHint, 0 );

   842     VGFont ret = ::vgCreateFont( glyphCapacityHint );

   843     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   844     return WriteReply();

   845 }

   846 

   847 

   848 int OpenVGAPIWrapper::vgDestroyFont()

   849 {

   850     VGFont font;

   851     m_currentFunctionCall.GetParamValue( font, 0 );

   852     ::vgDestroyFont( font );

   853     return WriteReply();

   854 }

   855 

   856 

   857 int OpenVGAPIWrapper::vgClearGlyph()

   858 {

   859     VGFont font;

   860     m_currentFunctionCall.GetParamValue( font, 0 );

   861     VGuint glyphIndex;

   862     m_currentFunctionCall.GetParamValue( glyphIndex, 1 );

   863     ::vgClearGlyph( font, glyphIndex );

   864     return WriteReply();

   865 }

   866 

   867 

   868 int OpenVGAPIWrapper::vgDrawGlyph()

   869 {

   870     VGFont font;

   871     m_currentFunctionCall.GetParamValue( font, 0 );

   872 

   873     VGuint glyphIndex;

   874     m_currentFunctionCall.GetParamValue( glyphIndex, 1 );

   875 

   876     VGbitfield paintModes;

   877     m_currentFunctionCall.GetParamValue( paintModes, 2 );

   878 

   879     VGboolean allowAutoHinting;

   880     m_currentFunctionCall.GetParamValue( allowAutoHinting, 3 );

   881 

   882     ::vgDrawGlyph( font, glyphIndex, paintModes, allowAutoHinting );

   883     return WriteReply();

   884 }

   885 

   886 

   887 int OpenVGAPIWrapper::vgGaussianBlur()

   888 {

   889     VGImage dst;

   890     m_currentFunctionCall.GetParamValue( dst, 0 );

   891     VGImage src;

   892     m_currentFunctionCall.GetParamValue( src, 1 );

   893     VGfloat stdDeviationX;

   894     m_currentFunctionCall.GetParamValue( stdDeviationX, 2 );

   895     VGfloat stdDeviationY;

   896     m_currentFunctionCall.GetParamValue( stdDeviationY, 3 );

   897     VGTilingMode tilingMode;

   898     m_currentFunctionCall.GetParamValue( tilingMode, 4 );

   899 

   900 	doSync( 5, dst, src );

   901 

   902     ::vgGaussianBlur( dst, src, stdDeviationX, stdDeviationY, tilingMode );

   903     return WriteReply();

   904 }

   905 

   906 

   907 int OpenVGAPIWrapper::vgHardwareQuery()

   908 {

   909     VGHardwareQueryType key;

   910     m_currentFunctionCall.GetParamValue( key, 0 );

   911     VGint setting;

   912     m_currentFunctionCall.GetParamValue( setting, 1 );

   913     VGHardwareQueryResult ret =::vgHardwareQuery( key, setting );

   914     m_currentFunctionCall.SetReturnValue( (TUint32)ret );

   915     return WriteReply();

   916 }

   917 

   918 

   919 int OpenVGAPIWrapper::vgWritePixels()

   920 {

   921     void* data;

   922     TInt size;

   923     m_currentFunctionCall.GetVectorData( data, size, 0 );

   924     VGint dataStride;

   925     m_currentFunctionCall.GetParamValue( dataStride, 1 );

   926     VGImageFormat dataFormat;

   927     m_currentFunctionCall.GetParamValue( dataFormat, 2 );

   928     VGint dx;

   929     m_currentFunctionCall.GetParamValue( dx, 3 );

   930     VGint dy;

   931     m_currentFunctionCall.GetParamValue( dy, 4 );

   932     VGint width;

   933     m_currentFunctionCall.GetParamValue( width, 5 );

   934     VGint height;

   935     m_currentFunctionCall.GetParamValue( height, 6 );

   936 

   937     ::vgWritePixels( data, dataStride, dataFormat, dx, dy, width, height );

   938     return WriteReply();

   939 }

   940 

   941 

   942 int OpenVGAPIWrapper::vgImageSubData()

   943 {

   944     VGImage image;

   945     m_currentFunctionCall.GetParamValue( image, 0 );

   946     void* data;

   947     TInt size;

   948     m_currentFunctionCall.GetVectorData( data, size, 1 );

   949     VGint dataStride;

   950     m_currentFunctionCall.GetParamValue( dataStride, 2 );

   951     VGImageFormat dataFormat;

   952     m_currentFunctionCall.GetParamValue( dataFormat, 3 );

   953     VGint x;

   954     m_currentFunctionCall.GetParamValue( x, 4 );

   955     VGint y;

   956     m_currentFunctionCall.GetParamValue( y, 5 );

   957     VGint width;

   958     m_currentFunctionCall.GetParamValue( width, 6 );

   959     VGint height;

   960     m_currentFunctionCall.GetParamValue( height, 7 );

   961 

   962 	doSync( 8, image );

   963 

   964     ::vgImageSubData( image, data, dataStride, dataFormat, x, y, width, height );

   965     return WriteReply();

   966 }

   967 

   968 

   969 int OpenVGAPIWrapper::vgSetParameteriv()

   970 {

   971     VGHandle object;

   972     m_currentFunctionCall.GetParamValue( object, 0 );

   973     VGint paramType;

   974     m_currentFunctionCall.GetParamValue( paramType, 1 );

   975     VGint count;

   976     m_currentFunctionCall.GetParamValue( count, 2 );

   977     VGint * values;

   978     TInt size;

   979     m_currentFunctionCall.GetVectorData( values, size, 3 );

   980 

   981     ::vgSetParameteriv( object, paramType, count, values );

   982     return WriteReply();

   983 }

   984 

   985 

   986 int OpenVGAPIWrapper::vgLoadMatrix()

   987 {

   988     VGfloat * m;

   989     TInt size;

   990     m_currentFunctionCall.GetVectorData( m, size, 0 );

   991     ::vgLoadMatrix( m );

   992     return WriteReply();

   993 }

   994 

   995 

   996 int OpenVGAPIWrapper::vgMultMatrix()

   997 {

   998     VGfloat * m;

   999     TInt size;

  1000     m_currentFunctionCall.GetVectorData( m, size, 0 );

  1001     ::vgMultMatrix( m );

  1002     return WriteReply();

  1003 }

  1004 

  1005 

  1006 int OpenVGAPIWrapper::vgModifyPathCoords()

  1007 {

  1008     VGPath dstPath;

  1009     m_currentFunctionCall.GetParamValue( dstPath, 0 );

  1010     VGint startIndex;

  1011     m_currentFunctionCall.GetParamValue( startIndex, 1 );

  1012     VGint numSegments;

  1013     m_currentFunctionCall.GetParamValue( numSegments, 2 );

  1014     void * pathData;

  1015     TInt size;

  1016     m_currentFunctionCall.GetVectorData( pathData, size, 3 );

  1017 

  1018     ::vgModifyPathCoords( dstPath, startIndex, numSegments, pathData);

  1019     return WriteReply();

  1020 }

  1021 

  1022 

  1023 int OpenVGAPIWrapper::vgSetGlyphToPath()

  1024 {

  1025     VGFont font;

  1026     m_currentFunctionCall.GetParamValue( font, 0 );

  1027     VGuint glyphIndex;

  1028     m_currentFunctionCall.GetParamValue( glyphIndex, 1 );

  1029     VGPath path;

  1030     m_currentFunctionCall.GetParamValue( path, 2 );

  1031     VGboolean isHinted;

  1032     m_currentFunctionCall.GetParamValue( isHinted, 3 );

  1033     VGfloat* glyphOrigin;

  1034     TInt size;

  1035     m_currentFunctionCall.GetVectorData( glyphOrigin, size, 4 );

  1036     VGfloat* escapement;

  1037     m_currentFunctionCall.GetVectorData( escapement, size, 5 );

  1038 

  1039     ::vgSetGlyphToPath( font, glyphIndex, path, isHinted, glyphOrigin, escapement );

  1040     return WriteReply();

  1041 }

  1042 

  1043 

  1044 int OpenVGAPIWrapper::vgSetGlyphToImage()

  1045 {

  1046     VGFont font;

  1047     m_currentFunctionCall.GetParamValue( font, 0 );

  1048     VGuint glyphIndex;

  1049     m_currentFunctionCall.GetParamValue( glyphIndex, 1 );

  1050     VGImage image;

  1051     m_currentFunctionCall.GetParamValue( image, 2 );

  1052     VGfloat* glyphOrigin;

  1053     TInt size;

  1054     m_currentFunctionCall.GetVectorData( glyphOrigin, size, 3 );

  1055     VGfloat* escapement;

  1056     m_currentFunctionCall.GetVectorData( escapement, size, 4 );

  1057 

  1058     ::vgSetGlyphToImage( font, glyphIndex, image, glyphOrigin, escapement );

  1059     return WriteReply();

  1060 }

  1061 

  1062 

  1063 int OpenVGAPIWrapper::vgDrawGlyphs()

  1064 {

  1065     VGFont font;

  1066     m_currentFunctionCall.GetParamValue( font, 0 );

  1067     VGint glyphCount;

  1068     m_currentFunctionCall.GetParamValue( glyphCount, 1 );

  1069     VGuint * glyphIndices;

  1070     TInt size;

  1071     m_currentFunctionCall.GetVectorData( glyphIndices, size, 2 );

  1072     VGfloat * adjustments_x;

  1073     m_currentFunctionCall.GetVectorData( adjustments_x, size, 3 );

  1074     VGfloat * adjustments_y;

  1075     m_currentFunctionCall.GetVectorData( adjustments_y, size, 4 );

  1076     VGbitfield paintModes;

  1077     m_currentFunctionCall.GetParamValue( paintModes, 5 );

  1078     VGboolean allowAutoHinting;

  1079     m_currentFunctionCall.GetParamValue( allowAutoHinting, 6 );

  1080 

  1081     ::vgDrawGlyphs( font, glyphCount, glyphIndices, adjustments_x, adjustments_y, paintModes, allowAutoHinting );

  1082     return WriteReply();

  1083 }

  1084 

  1085 

  1086 int OpenVGAPIWrapper::vgColorMatrix()

  1087 {

  1088     VGImage dst;

  1089     m_currentFunctionCall.GetParamValue( dst, 0 );

  1090     VGImage src;

  1091     m_currentFunctionCall.GetParamValue( src, 1 );

  1092     VGfloat * matrix;

  1093     TInt size;

  1094     m_currentFunctionCall.GetVectorData( matrix, size, 2 );

  1095 

  1096 	doSync( 3, dst, src );

  1097 

  1098     ::vgColorMatrix( dst, src, matrix );

  1099     return WriteReply();

  1100 }

  1101 

  1102 

  1103 int OpenVGAPIWrapper::vgConvolve()

  1104 {

  1105     VGImage dst;

  1106     m_currentFunctionCall.GetParamValue( dst, 0 );

  1107     VGImage src;

  1108     m_currentFunctionCall.GetParamValue( src, 1 );

  1109     VGint kernelWidth;

  1110     m_currentFunctionCall.GetParamValue( kernelWidth, 2 );

  1111     VGint kernelHeight;

  1112     m_currentFunctionCall.GetParamValue( kernelHeight, 3 );

  1113     VGint shiftX;

  1114     m_currentFunctionCall.GetParamValue( shiftX, 4 );

  1115     VGint shiftY;

  1116     m_currentFunctionCall.GetParamValue( shiftY, 5 );

  1117     VGshort * kernel;

  1118     TInt size;

  1119     m_currentFunctionCall.GetVectorData( kernel, size, 6 );

  1120     VGfloat scale;

  1121     m_currentFunctionCall.GetParamValue( scale, 7 );

  1122     VGfloat bias;

  1123     m_currentFunctionCall.GetParamValue( bias, 8 );

  1124     VGTilingMode tilingMode;

  1125     m_currentFunctionCall.GetParamValue( tilingMode, 9 );

  1126 

  1127 	doSync( 10, dst, src );

  1128 

  1129     ::vgConvolve( dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernel, scale, bias, tilingMode );

  1130     return WriteReply();

  1131 }

  1132 

  1133