Mercurial Mercurial > oss > FCL > sf > adapt > graphics.simulator / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
guestrendering/guestvideodriver/ldd/src/devicereqhandler.cpp
branchbug235_bringup_0
changeset 2 e8ccf068ac7f
parent 1 d8d95053303a
child 3 ccf5191a9db1
equal deleted inserted replaced
1:d8d95053303a 2:e8ccf068ac7f 
    22 #include <platform.h>
 
    22 #include <platform.h>
 
    23 #include <assp.h>
 
    23 #include <assp.h>
 
    24 #include <kernel/kernel.h>
 
    24 #include <kernel/kernel.h>
 
    25 #include <e32cmn.h>
 
    25 #include <e32cmn.h>
 
    26 
    26 
    27 #include "devicereqhandler.h"
 
    27 #include <graphics/devicereqhandler.h>
 
    28 #include "virtualvideohwinterface.h"
 
    28 #include <graphics/virtualvideohwinterface.h>
 
    29 
    29 #include <graphics/virtualvideotracing.h>
 
    30 #include "virtualvideotracing.h"
 
       
    31 
    30 
    32 #include "remotefunctioncall.h"
 
    31 #include "remotefunctioncall.h"
 
    33 #include "serializedfunctioncall.h"
 
    32 #include "serializedfunctioncall.h"
 
    34 #include "driverrfc.h"
 
    33 #include "driverrfc.h"
 
    35 #include "openvgrfc.h" //For the opcodes
 
    34 #include "openvgrfc.h" //For the opcodes
 
    36 #include "eglrfc.h" //For the opcodes
 
    35 #include "eglrfc.h" //For the opcodes
 
    37 #include "opengles11rfc.h" //For the opcodes
 
    36 #include "opengles11rfc.h" //For the opcodes
 
    38 
    37 
    39 
    38 
    40 using namespace PlatsimVideoDriver;
 
    39 using namespace GuestVideoDriver;
 
    41 
    40 
    42 // LOCAL DATA TYPES
 
    41 // LOCAL DATA TYPES
 
    43 TInt CmpTPbsIds(const TPbSId& a, const TPbSId& b)
 
    42 TInt CmpTPbsIds(const TPbSId& a, const TPbSId& b)
 
    44     {
 
    43     {
 
    45     if( a.iPbuffer == b.iPbuffer )
 
    44     if( a.iPbuffer == b.iPbuffer )
 
   736     else
 
   735     else
 
   737         {
 
   736         {
 
   738         return;//No sgImage handle appended on the client side, just exit
 
   737         return;//No sgImage handle appended on the client side, just exit
 
   739         }
 
   738         }
 
   740     
   739     
       
   740 #ifdef FAISALMEMON_S4_SGIMAGE
 
   741     if( sgId != NULL )
 
   741     if( sgId != NULL )
 
   742         {
 
   742         {
 
   743         VVHW_TRACE( "DDeviceReqHandler::getVGSyncInOp SgImage-backing VGImage found" );
 
   743         VVHW_TRACE( "DDeviceReqHandler::getVGSyncInOp SgImage-backing VGImage found" );
 
   744         DSgResource* resource;
 
   744         DSgResource* resource;
 
   745         HBuf8* data = OpenSgImageMetaData( sgId, resource );
 
   745         HBuf8* data = OpenSgImageMetaData( sgId, resource );
 
   765         }
 
   765         }
 
   766     if( syncNeeded )
 
   766     if( syncNeeded )
 
   767         {
 
   767         {
 
   768         call.AppendParam ( (int)surface );
 
   768         call.AppendParam ( (int)surface );
 
   769         }
 
   769         }
 
       
   770 #endif
 
   770     }
 
   771     }
 
   771 
   772 
   772 
   773 
   773 void DDeviceReqHandler::ConsumeSchedulerInitiatedRequestResult( TAsyncRequest* aReq )
 
   774 void DDeviceReqHandler::ConsumeSchedulerInitiatedRequestResult( TAsyncRequest* aReq )
 
   774     {
 
   775     {
 
  1001     TAsyncRequest* req(0);
 
  1002     TAsyncRequest* req(0);
 
  1002     TPckg<TUint32> res( iOpReturn );
 
  1003     TPckg<TUint32> res( iOpReturn );
 
  1003     EGLSurface surface(0);
 
  1004     EGLSurface surface(0);
 
  1004     VGImage    image(0);
 
  1005     VGImage    image(0);
 
  1005     
  1006     
       
  1007 #ifdef FAISALMEMON_S4_SGIMAGE
 
  1006     DSgResource* resource;
 
  1008     DSgResource* resource;
 
  1007     HBuf8* data = OpenSgImageMetaData( aId, resource );
 
  1009     HBuf8* data = OpenSgImageMetaData( aId, resource );
 
  1008     if( data )
 
  1010     if( data )
 
  1009         {
 
  1011         {
 
  1010         TSgImageMetaData sginfo (((TPckgBuf<TSgImageMetaData>*) data)->operator ()());
 
  1012         TSgImageMetaData sginfo (((TPckgBuf<TSgImageMetaData>*) data)->operator ()());
 
  1038         }
 
  1040         }
 
  1039     while( status == KRequestPending )
 
  1041     while( status == KRequestPending )
 
  1040         {
 
  1042         {
 
  1041         NKern::Sleep( 20 );
 
  1043         NKern::Sleep( 20 );
 
  1042         }
 
  1044         }
 
       
  1045 #endif
 
       
  1046 
  1043     VVHW_TRACE("DDeviceReqHandler::DestroySgImage <-");
 
  1047     VVHW_TRACE("DDeviceReqHandler::DestroySgImage <-");
 
  1044     return 1;
 
  1048     return 1;
 
  1045     }
 
  1049     }
 
  1046 
  1050 
  1047 
  1051 
  1249                     EGLint* handles;
 
  1253                     EGLint* handles;
 
  1250                     EGLint handles_size;
 
  1254                     EGLint handles_size;
 
  1251                     
  1255                     
  1252                     call.GetTUint64( id, 0 );
 
  1256                     call.GetTUint64( id, 0 );
 
  1253                     call.GetEGLintVectorData( handles, handles_size, 2 );
 
  1257                     call.GetEGLintVectorData( handles, handles_size, 2 );
 
       
  1258 #ifdef FAISALMEMON_S4_SGIMAGE
 
  1254                     DSgResource* resource;
 
  1259                     DSgResource* resource;
 
  1255                     VVHW_TRACE("EglRFC::EeglMetaSgGetHandles openSgImageMetaData" );
 
  1260                     VVHW_TRACE("EglRFC::EeglMetaSgGetHandles openSgImageMetaData" );
 
  1256                     HBuf8* data = OpenSgImageMetaData( id, resource );
 
  1261                     HBuf8* data = OpenSgImageMetaData( id, resource );
 
  1257                     if( data && handles_size >= 2 )
 
  1262                     if( data && handles_size >= 2 )
 
  1258                         {
 
  1263                         {
 
  1264                     else
 
  1269                     else
 
  1265                         {
 
  1270                         {
 
  1266                         call.SetReturnValue( (int)EGL_FALSE );
 
  1271                         call.SetReturnValue( (int)EGL_FALSE );
 
  1267                         }
 
  1272                         }
 
  1268                     alreadyProcessed = EHandled;
 
  1273                     alreadyProcessed = EHandled;
 
       
  1274 #endif
 
  1269 					break;
 
  1275 					break;
 
  1270                     }
 
  1276                     }
 
  1271                 case EglRFC::EeglCreateContext:
 
  1277                 case EglRFC::EeglCreateContext:
 
  1272                     {
 
  1278                     {
 
  1273                     //if no share_context specified, pass the sgImage pool context
 
  1279                     //if no share_context specified, pass the sgImage pool context
 
  1292                     TPbSId obj ( draw, 0 );
 
  1298                     TPbSId obj ( draw, 0 );
 
  1293 
  1299 
  1294                     TInt sgIdIndex = iPbufferSgMap.FindInOrder( obj, iPbufferSgMapOrder );
 
  1300                     TInt sgIdIndex = iPbufferSgMap.FindInOrder( obj, iPbufferSgMapOrder );
 
  1295                     if( sgIdIndex != KErrNotFound )
 
  1301                     if( sgIdIndex != KErrNotFound )
 
  1296                         {
 
  1302                         {
 
       
  1303 #ifdef FAISALMEMON_S4_SGIMAGE
 
  1297                         DSgResource* resource;
 
  1304                         DSgResource* resource;
 
  1298                         HBuf8* data = OpenSgImageMetaData( iPbufferSgMap[sgIdIndex].iSgId, resource );
 
  1305                         HBuf8* data = OpenSgImageMetaData( iPbufferSgMap[sgIdIndex].iSgId, resource );
 
  1299                         if( data )
 
  1306                         if( data )
 
  1300                             {
 
  1307                             {
 
  1301                             TSgImageMetaData sginfo (((TPckgBuf<TSgImageMetaData>*) data)->operator ()());
 
  1308                             TSgImageMetaData sginfo (((TPckgBuf<TSgImageMetaData>*) data)->operator ()());
 
  1307                                 syncRequirement = syncRequirement | KSyncDrawSurface;
 
  1314                                 syncRequirement = syncRequirement | KSyncDrawSurface;
 
  1308                                 call.AppendEGLint( img );
 
  1315                                 call.AppendEGLint( img );
 
  1309                                 }
 
  1316                                 }
 
  1310                             delete data;
 
  1317                             delete data;
 
  1311                             }
 
  1318                             }
 
       
  1319 #endif
 
  1312                         }
 
  1320                         }
 
  1313                     obj.iPbuffer = read;
 
  1321                     obj.iPbuffer = read;
 
  1314                     obj.iSgId = 0;
 
  1322                     obj.iSgId = 0;
 
  1315 
  1323 
  1316                     sgIdIndex = iPbufferSgMap.FindInOrder( obj, iPbufferSgMapOrder );
 
  1324                     sgIdIndex = iPbufferSgMap.FindInOrder( obj, iPbufferSgMapOrder );
 
  1317                     if( sgIdIndex != KErrNotFound )
 
  1325                     if( sgIdIndex != KErrNotFound )
 
  1318                         {
 
  1326                         {
 
       
  1327 #ifdef FAISALMEMON_S4_SGIMAGE
 
  1319                         DSgResource* resource;
 
  1328                         DSgResource* resource;
 
  1320                         HBuf8* data = OpenSgImageMetaData( iPbufferSgMap[sgIdIndex].iSgId, resource );
 
  1329                         HBuf8* data = OpenSgImageMetaData( iPbufferSgMap[sgIdIndex].iSgId, resource );
 
  1321                         if( data )
 
  1330                         if( data )
 
  1322                             {
 
  1331                             {
 
  1323                             TSgImageMetaData sginfo (((TPckgBuf<TSgImageMetaData>*) data)->operator ()());
 
  1332                             TSgImageMetaData sginfo (((TPckgBuf<TSgImageMetaData>*) data)->operator ()());
 
  1328                                 //sync with the underlying pbuffer surface
 
  1337                                 //sync with the underlying pbuffer surface
 
  1329                                 syncRequirement = syncRequirement | KSyncReadSurface;
 
  1338                                 syncRequirement = syncRequirement | KSyncReadSurface;
 
  1330                                 }
 
  1339                                 }
 
  1331                             delete data;
 
  1340                             delete data;
 
  1332                             }
 
  1341                             }
 
       
  1342 #endif
 
  1333                         }
 
  1343                         }
 
  1334                     call.AppendEGLint( syncRequirement );
 
  1344                     call.AppendEGLint( syncRequirement );
 
  1335                     call.AppendEGLint( img );
 
  1345                     call.AppendEGLint( img );
 
  1336                     
  1346                     
  1337                     VVHW_TRACE("eglMakeCurrent %u", iCurrClientData->iContext );
 
  1347                     VVHW_TRACE("eglMakeCurrent %u", iCurrClientData->iContext );
 
  1348                     
  1358                     
  1349                     TUint64 sgId;
 
  1359                     TUint64 sgId;
 
  1350                     EglRFC call( aReq->iRemoteFunctionCall );
 
  1360                     EglRFC call( aReq->iRemoteFunctionCall );
 
  1351                     call.GetTUint64( sgId, 0 );//get the sgImage id
 
  1361                     call.GetTUint64( sgId, 0 );//get the sgImage id
 
  1352                     
  1362                     
       
  1363 #ifdef FAISALMEMON_S4_SGIMAGE
 
  1353                     DSgResource* resource;
 
  1364                     DSgResource* resource;
 
  1354                     HBuf8* data = OpenSgImageMetaData( sgId, resource );
 
  1365                     HBuf8* data = OpenSgImageMetaData( sgId, resource );
 
  1355                     if( data )
 
  1366                     if( data )
 
  1356                         {
 
  1367                         {
 
  1357                             TSgImageMetaData sginfo (((TPckgBuf<TSgImageMetaData>*) data)->operator ()());
 
  1368                             TSgImageMetaData sginfo (((TPckgBuf<TSgImageMetaData>*) data)->operator ()());
 
  1362                     else
 
  1373                     else
 
  1363                         {
 
  1374                         {
 
  1364                         aReq->iRemoteFunctionCall.SetReturnValue( EGL_NO_SURFACE );
 
  1375                         aReq->iRemoteFunctionCall.SetReturnValue( EGL_NO_SURFACE );
 
  1365                         }
 
  1376                         }
 
  1366                     //Find the sgimage's pbuffer surface, then return that
 
  1377                     //Find the sgimage's pbuffer surface, then return that
 
       
  1378 #endif
 
  1367                     VVHW_TRACE( "EeglCreatePixmapSurfaceSg" );
 
  1379                     VVHW_TRACE( "EeglCreatePixmapSurfaceSg" );
 
  1368                     break;
 
  1380                     break;
 
  1369                     }
 
  1381                     }
 
  1370                 case EglRFC::EeglCreatePbufferFromClientBuffer:
 
  1382                 case EglRFC::EeglCreatePbufferFromClientBuffer:
 
  1371                     {
 
  1383                     {
FCL/sf/adapt/graphics.simulator