--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vghwinterface/vghwserialiser/src/serializedfunctioncall.cpp Wed Oct 06 15:43:10 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*)¶m.iDir, sizeof(param.iDir) );
+ if ( ReadParam( (TUint8*)¶m.iType, sizeof(param.iType) ) )
+ {
+
+ if ( RemoteFunctionCallData::TParam::ESimple == param.iType )
+ {
+ ReadParam( (TUint8*)¶m.iSimpleParam.iDataType, sizeof(param.iSimpleParam.iDataType) );
+ ReadParam( (TUint8*)¶m.iSimpleParam.iDataTypeSize, sizeof(param.iSimpleParam.iDataTypeSize) );
+ ReadParam( (TUint8*)¶m.iSimpleParam.iData, param.iSimpleParam.iDataTypeSize );
+ }
+ else if ( RemoteFunctionCallData::TParam::EVector == param.iType )
+ {
+ ReadParam( (TUint8*)¶m.iVectorParam.iDataType, sizeof(param.iVectorParam.iDataType) );
+ ReadParam( (TUint8*)¶m.iVectorParam.iVectorLength, sizeof(param.iVectorParam.iVectorLength) );
+ ReadParam( (TUint8*)¶m.iVectorParam.iCallerAddress, sizeof(param.iVectorParam.iCallerAddress) );
+ ReadParam( (TUint8*)¶m.iVectorParam.iDataTypeSize, sizeof(param.iVectorParam.iDataTypeSize) );
+ ReadParam( (TUint8*)¶m.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*)¶m.iDir,
+ sizeof(param.iDir) ) )
+ {
+ break;
+ }
+
+ if ( !WriteParam( (TUint8*)¶m.iType,
+ sizeof(param.iType) ) )
+ {
+ break;
+ }
+
+ if ( RemoteFunctionCallData::TParam::ESimple == param.iType )
+ {
+ if ( !WriteParam( (TUint8*)¶m.iSimpleParam.iDataType,
+ sizeof(param.iSimpleParam.iDataType) ) )
+ {
+ break;
+ }
+ if ( !WriteParam( (TUint8*)¶m.iSimpleParam.iDataTypeSize,
+ sizeof(param.iSimpleParam.iDataTypeSize) ) )
+ {
+ break;
+ }
+
+ if ( !WriteParam( (TUint8*)¶m.iSimpleParam.iData, param.iSimpleParam.iDataTypeSize ) )
+ {
+ break;
+ }
+ }
+ else if ( RemoteFunctionCallData::TParam::EVector == param.iType )
+ {
+ if ( !WriteParam( (TUint8*)¶m.iVectorParam.iDataType, sizeof(param.iVectorParam.iDataType) ))
+ {
+ break;
+ }
+
+ if ( !WriteParam( (TUint8*)¶m.iVectorParam.iVectorLength, sizeof(param.iVectorParam.iVectorLength) ))
+ {
+ break;
+ }
+
+ if ( !WriteParam( (TUint8*)¶m.iVectorParam.iCallerAddress, sizeof(param.iVectorParam.iCallerAddress) ))
+ {
+ break;
+ }
+
+ if ( !WriteParam( (TUint8*)¶m.iVectorParam.iDataTypeSize, sizeof(param.iVectorParam.iDataTypeSize) ))
+ {
+ break;
+ }
+
+ if ( !WriteParam( (TUint8*)¶m.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 )
+ {
+ }