diff -r 013716db5021 -r d8d95053303a guestrendering/vghwserialiser/src/serializedfunctioncall.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/guestrendering/vghwserialiser/src/serializedfunctioncall.cpp	Fri Aug 20 18:02:40 2010 +0100
@@ -0,0 +1,495 @@
+// 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:
+
+#include "serializedfunctioncall.h"
+#include "remotefunctioncall.h"
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+TInt SerializedFunctionCall::Write( TUint8* aDest, TInt& aDestIndex, const TInt aDestSize,
+        const TUint8* aSource, const TInt aSize, TInt& aSourceIndex, const TInt aOffset, TBool aVector )
+    {        
+    if ( aSourceIndex + aSize > aOffset )
+        {
+        TInt32 offset(0);
+        TInt32 size( aSize );  
+        if ( aOffset - aSourceIndex > 0 )
+            {
+            offset = aOffset - aSourceIndex;
+            size = aSize - offset;
+            }
+
+        if ( aDestIndex + size >= aDestSize )
+            {
+            size = aDestSize - aDestIndex;
+            }
+
+        if ( aSource )
+            {
+            if ( iDataCopier && aVector )
+                {
+                iDataCopier->CopyVector( &aDest[aDestIndex], &aSource[offset], size );
+                }
+            else if ( iDataCopier )
+                {
+                iDataCopier->CopyData( &aDest[aDestIndex], &aSource[offset], size );            
+                }
+            else
+                {
+				RemoteFunctionCallData::CopyData( &aDest[aDestIndex], &aSource[offset], size );
+                }
+            }
+        aSourceIndex += size;
+        aDestIndex += size;
+        }
+    else
+        {
+        aSourceIndex += aSize;
+        }
+    return aDestSize - aDestIndex; 
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+TInt SerializedFunctionCall::WriteParam( const TUint8* aParam, const TInt aParamSize )
+    {
+    ASSERT( aParam );
+
+    return Write( iWriteState.iBuffer, iWriteState.iDestIndex, iWriteState.iStreamMaxLength,
+            aParam, aParamSize, iWriteState.iSourceIndex, iWriteState.iOffset, 0 );        
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+TInt SerializedFunctionCall::WriteVector( const TUint8* aParam, const TInt32 aDataTypeSize, const TInt aVectorSize, const TInt8 aDataTypeAlignment )
+    {
+    ASSERT( aParam );
+    iWriteState.iDestIndex = RemoteFunctionCallData::AlignIndex( iWriteState.iDestIndex, aDataTypeAlignment );
+    return Write( iWriteState.iBuffer, iWriteState.iDestIndex, iWriteState.iStreamMaxLength,
+            aParam, aVectorSize*aDataTypeSize, iWriteState.iSourceIndex, iWriteState.iOffset, 1 );        
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+TInt SerializedFunctionCall::ReadParam( TUint8* aParam, const TInt aParamSize )
+    {
+    return Read( aParam, iReadState.iReadDestOffset, aParamSize, 
+        iReadState.iReadBuffer, iReadState.iReadBufferIndex, iReadState.iReadBufferLength, 0 );        
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+TInt SerializedFunctionCall::ReadVectorParam( TUint8* aParam, 
+		const TInt32 aDataTypeSize, const TInt aVectorSize, const TInt8 aDataTypeAlignment )
+    {
+	iReadState.iReadBufferIndex = RemoteFunctionCallData::AlignIndex( iReadState.iReadBufferIndex, aDataTypeAlignment );
+    return Read( aParam, iReadState.iReadDestOffset, aVectorSize*aDataTypeSize, 
+        iReadState.iReadBuffer, iReadState.iReadBufferIndex, iReadState.iReadBufferLength, 1 );        
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+TUint8* SerializedFunctionCall::ReadVectorPointer( 
+		const TInt32 aDataTypeSize, const TInt aVectorSize, const TInt8 aDataTypeAlignment )
+    {
+	iReadState.iReadBufferIndex = RemoteFunctionCallData::AlignIndex( iReadState.iReadBufferIndex, aDataTypeAlignment );
+	TUint8* data = const_cast<TUint8*>(&iReadState.iReadBuffer[iReadState.iReadBufferIndex]);
+	iReadState.iReadBufferIndex += aVectorSize*aDataTypeSize;
+    iReadState.iReadDestOffset += 0;
+	return data;
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+TInt SerializedFunctionCall::Read( TUint8* aDest, TInt& aDestIndex, const TInt aDestSize,
+        const TUint8* aSource, TInt& aSourceIndex, const TInt aSourceSize, TBool aVector )
+    {
+    TInt ret(1);
+    TInt size = aDestSize - aDestIndex;
+    if ( aSourceIndex + size > aSourceSize )
+        {
+        //Read buffer overflow
+        iError = EMoreData;
+        ret = 0;
+        size = aSourceSize - aSourceIndex; 
+        }
+    
+    if ( iDataCopier && aVector )
+        {
+        iDataCopier->CopyVector( &aDest[aDestIndex], &aSource[aSourceIndex], size );
+        }
+    else if ( iDataCopier )
+        {
+        iDataCopier->CopyData( &aDest[aDestIndex], &aSource[aSourceIndex], size );            
+        }
+    else
+        {
+		RemoteFunctionCallData::CopyData( &aDest[aDestIndex], &aSource[aSourceIndex], size );
+        }
+
+    aSourceIndex += size;
+    aDestIndex += size;
+    
+    if ( ret )
+        {
+        aDestIndex = 0;
+        }
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+void SerializedFunctionCall::StartRead( const TUint8* aBuffer, const TInt aBufferLength )
+    {
+    iReadState.iReadBuffer = aBuffer;
+    iReadState.iReadBufferIndex = 0;
+    iReadState.iReadBufferLength = aBufferLength;
+    iReadState.iParseState = EReadingApiUid;
+    iReadState.iReadDestOffset = 0;
+    iError = ESuccess;
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+TInt SerializedFunctionCall::ReadHeaderFromBuffer( const TUint8* aBuffer, const TInt aBufferLength )
+    {
+    iReadState.iParamsIndex = 0;
+    StartRead( aBuffer, aBufferLength );
+
+    if ( EReadingApiUid == iReadState.iParseState )
+        {
+        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iApiUid, 
+                sizeof(iRFC.HeaderData().iApiUid) ) )
+            {
+            return 0;
+            }
+        iReadState.iParseState = EReadingOpCode;
+        }
+
+	if ( EReadingOpCode == iReadState.iParseState )
+        {
+        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iOpCode, 
+                sizeof(iRFC.HeaderData().iOpCode) ) )
+            {
+            return 0;
+            }
+        iReadState.iParseState = EReadingTransactionId;
+        }
+
+    if ( iReadState.iParseState == EReadingTransactionId )
+        {
+        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iTransactionId, 
+                sizeof(iRFC.HeaderData().iTransactionId) ) )
+            {
+            return 0;
+            }
+        iReadState.iParseState = EReadingParameterCount;
+        }
+    if ( iReadState.iParseState == EReadingParameterCount )
+        {
+        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iParameterCount, 
+                sizeof(iRFC.HeaderData().iParameterCount) ) )
+            {
+            return 0;
+            }
+        iReadState.iParseState = EReadingProcessId;
+        }
+    if ( iReadState.iParseState == EReadingProcessId )
+        {
+        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iProcessId, 
+                sizeof(iRFC.HeaderData().iProcessId) ) )
+            {
+            return 0;
+            }
+        iReadState.iParseState = EReadingThreadId;
+        }
+    if ( iReadState.iParseState == EReadingThreadId )
+        {
+        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iThreadId, 
+                sizeof(iRFC.HeaderData().iThreadId) ) )
+            {
+            return 0;
+            }
+        iReadState.iParseState = EReadingOpType;
+        }
+    if ( iReadState.iParseState == EReadingOpType )
+        {
+        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iOpType, 
+                sizeof(iRFC.HeaderData().iOpType) ) )
+            {
+            return 0;
+            }
+        iReadState.iParseState = EReadingReturnValue;
+        }
+    if ( iReadState.iParseState == EReadingReturnValue )
+        {
+        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iReturnValue, 
+                sizeof(iRFC.HeaderData().iReturnValue) ) )
+            {
+            return 0;
+            }
+        iReadState.iParseState = EReadingParamDir;
+        }
+    
+    return 1;
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+SER_EXPORT_C TInt SerializedFunctionCall::ParseBuffer( const TUint8* aBuffer, const TInt aBufferLength )
+    {
+    StartRead( aBuffer, aBufferLength );
+    if ( ReadHeaderFromBuffer( aBuffer, aBufferLength ) )
+        {        
+        for ( ;iReadState.iParamsIndex < iRFC.Header().iParameterCount; iReadState.iParamsIndex++ )
+            {
+			RemoteFunctionCallData::TParam& param( iRFC.Parameters()[iReadState.iParamsIndex] );
+    
+            ReadParam( (TUint8*)&param.iDir, sizeof(param.iDir) );
+            if ( ReadParam( (TUint8*)&param.iType, sizeof(param.iType) ) )
+                {
+    
+                if ( RemoteFunctionCallData::TParam::ESimple == param.iType )
+                    {
+                    ReadParam( (TUint8*)&param.iSimpleParam.iDataType, sizeof(param.iSimpleParam.iDataType) ); 
+                    ReadParam( (TUint8*)&param.iSimpleParam.iDataTypeSize, sizeof(param.iSimpleParam.iDataTypeSize) ); 
+                    ReadParam( (TUint8*)&param.iSimpleParam.iData, param.iSimpleParam.iDataTypeSize );
+                    }
+                else if ( RemoteFunctionCallData::TParam::EVector == param.iType )
+                    {
+                    ReadParam( (TUint8*)&param.iVectorParam.iDataType, sizeof(param.iVectorParam.iDataType) );
+                    ReadParam( (TUint8*)&param.iVectorParam.iVectorLength, sizeof(param.iVectorParam.iVectorLength) );            
+                    ReadParam( (TUint8*)&param.iVectorParam.iCallerAddress, sizeof(param.iVectorParam.iCallerAddress) );
+                    ReadParam( (TUint8*)&param.iVectorParam.iDataTypeSize, sizeof(param.iVectorParam.iDataTypeSize) );
+                    ReadParam( (TUint8*)&param.iVectorParam.iDataTypeAlignment, sizeof(param.iVectorParam.iDataTypeAlignment) );
+                    
+                    if ( !param.iVectorParam.iVectorLength )
+                        {
+                        param.iVectorParam.iData = NULL;
+						param.iVectorParam.iCallerAddress = NULL;
+                        }
+                    else if ( (param.iDir & RemoteFunctionCallData::EIn) && ( RemoteFunctionCallData::EOpRequest == iRFC.Header().iOpType || RemoteFunctionCallData::EOpRequestWithReply == iRFC.Header().iOpType ) )
+                        {
+                        param.iVectorParam.iData = ReadVectorPointer( param.iVectorParam.iDataTypeSize, param.iVectorParam.iVectorLength, param.iVectorParam.iDataTypeAlignment );
+                        }
+                    else if ( (param.iDir & RemoteFunctionCallData::EOut) && iRFC.Header().iOpType == RemoteFunctionCallData::EOpReply ) 
+                        {
+                        ReadVectorParam( (TUint8*)param.iVectorParam.iCallerAddress, 
+                                param.iVectorParam.iDataTypeSize, param.iVectorParam.iVectorLength, param.iVectorParam.iDataTypeAlignment );
+                        }
+                    }
+                else
+                    {
+                    //Parse error
+                    iError = EParseError;
+                    return -1;
+                    }
+                }
+            }
+        iReadState.iParseState = EReadingDone;
+        }
+    else
+        {
+        iError = EParseError;
+        return -1;
+        }
+    return iReadState.iReadBufferIndex;
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+void SerializedFunctionCall::StartWrite( TUint8* aBuffer, const TInt aStreamMaxLength, TInt aOffset )
+    {
+    iWriteState.iBuffer = aBuffer;
+    iWriteState.iDestIndex = 0;
+    iWriteState.iStreamMaxLength = aStreamMaxLength;
+    iWriteState.iSourceIndex = 0;
+    iWriteState.iOffset = aOffset;
+    iError = ESuccess;    
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+TInt SerializedFunctionCall::WriteHeaderToBuffer( TUint8* aBuffer, const TInt aStreamMaxLength, TInt aOffset )
+    {
+    StartWrite( aBuffer, aStreamMaxLength, aOffset );
+    if ( !WriteParam( (TUint8*)&iRFC.Header().iApiUid, 
+            sizeof(iRFC.Header().iApiUid) ) )
+        {
+        return iWriteState.iSourceIndex;
+        }
+    if ( !WriteParam( (TUint8*)&iRFC.Header().iOpCode, 
+            sizeof(iRFC.Header().iOpCode) ) )
+        {
+        return iWriteState.iSourceIndex;
+        }
+    if ( !WriteParam( (TUint8*)&iRFC.Header().iTransactionId, 
+            sizeof(iRFC.Header().iTransactionId) ) )
+        {
+        return iWriteState.iSourceIndex;
+        }
+    if ( !WriteParam( (TUint8*)&iRFC.Header().iParameterCount, 
+            sizeof(iRFC.Header().iParameterCount) ) )
+        {
+        return iWriteState.iSourceIndex;
+        }
+    if ( !WriteParam( (TUint8*)&iRFC.Header().iProcessId, 
+            sizeof(iRFC.Header().iProcessId) ) )
+        {
+        return iWriteState.iSourceIndex;
+        }
+    if ( !WriteParam( (TUint8*)&iRFC.Header().iThreadId, 
+            sizeof(iRFC.Header().iThreadId) ) )
+        {
+        return iWriteState.iSourceIndex;
+        }
+    if ( !WriteParam( (TUint8*)&iRFC.Header().iOpType, 
+            sizeof(iRFC.Header().iOpType) ) )
+        {
+        return iWriteState.iSourceIndex;
+        }
+    if ( !WriteParam( (TUint8*)&iRFC.Header().iReturnValue, 
+            sizeof(iRFC.Header().iReturnValue) ) )
+        {
+        return iWriteState.iSourceIndex;
+        }
+    return iWriteState.iSourceIndex;
+    }
+
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+SER_EXPORT_C TInt SerializedFunctionCall::WriteToBuffer( TUint8* aBuffer, const TInt aStreamMaxLength, TInt aOffset )
+    {
+    WriteHeaderToBuffer( aBuffer, aStreamMaxLength, aOffset );
+    for ( TInt i = 0; i < iRFC.Header().iParameterCount; i++ )
+        {
+        const RemoteFunctionCallData::TParam& param( iRFC.Parameters()[i] );
+        
+        if ( !WriteParam( (TUint8*)&param.iDir, 
+                sizeof(param.iDir) ) )
+            {
+            break;
+            }
+
+        if ( !WriteParam( (TUint8*)&param.iType, 
+                sizeof(param.iType) ) )
+            {
+            break;
+            }
+        
+		if ( RemoteFunctionCallData::TParam::ESimple == param.iType )
+            {
+            if ( !WriteParam( (TUint8*)&param.iSimpleParam.iDataType, 
+                    sizeof(param.iSimpleParam.iDataType) ) )
+                {
+                break;
+                }
+            if ( !WriteParam( (TUint8*)&param.iSimpleParam.iDataTypeSize, 
+                    sizeof(param.iSimpleParam.iDataTypeSize) ) )
+                {
+                break;
+                }
+
+			if ( !WriteParam( (TUint8*)&param.iSimpleParam.iData, param.iSimpleParam.iDataTypeSize ) )
+                {
+                break;
+                }
+            }
+        else if ( RemoteFunctionCallData::TParam::EVector == param.iType )
+            {
+            if ( !WriteParam( (TUint8*)&param.iVectorParam.iDataType, sizeof(param.iVectorParam.iDataType) ))
+                {
+                break;
+                }
+
+            if ( !WriteParam( (TUint8*)&param.iVectorParam.iVectorLength, sizeof(param.iVectorParam.iVectorLength) ))
+                {
+                break;
+                }
+
+            if ( !WriteParam( (TUint8*)&param.iVectorParam.iCallerAddress, sizeof(param.iVectorParam.iCallerAddress) ))
+                {
+                break;
+                }
+
+            if ( !WriteParam( (TUint8*)&param.iVectorParam.iDataTypeSize, sizeof(param.iVectorParam.iDataTypeSize) ))
+                {
+                break;
+                }
+
+            if ( !WriteParam( (TUint8*)&param.iVectorParam.iDataTypeAlignment, sizeof(param.iVectorParam.iDataTypeAlignment) ))
+                {
+                break;
+                }
+
+            if ( param.iVectorParam.iVectorLength && ( ( (param.iDir & RemoteFunctionCallData::EIn) && ( RemoteFunctionCallData::EOpRequestWithReply == iRFC.Header().iOpType || RemoteFunctionCallData::EOpRequest == iRFC.Header().iOpType ) ) ||
+                    ( (param.iDir & RemoteFunctionCallData::EOut) && iRFC.Header().iOpType == RemoteFunctionCallData::EOpReply ) ) )
+                {
+                //Only serialise vector data if data is valid and the direction matches
+                if ( !WriteVector( param.iVectorParam.iData, param.iVectorParam.iDataTypeSize, param.iVectorParam.iVectorLength, param.iVectorParam.iDataTypeAlignment ) )
+                    {
+                    break;
+                    }
+                }
+            }
+        }
+    
+    return iWriteState.iDestIndex;
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+SER_EXPORT_C void SerializedFunctionCall::SetDataCopier( MDataCopier* aDataCopier )
+    {
+    iDataCopier = aDataCopier;        
+    }
+
+// -----------------------------------------------------------------------------
+// 
+// -----------------------------------------------------------------------------
+//
+SER_EXPORT_C SerializedFunctionCall::SerializedFunctionCall( RemoteFunctionCallData& aRFC, MDataCopier* aDataCopier ):
+	iRFC( aRFC ),
+    iDataCopier( aDataCopier )
+    {
+    }