diff -r 3b4f7e9d873f -r 4f400a6ea71f guestrendering/vghwserialiser/src/serializedfunctioncall.cpp --- a/guestrendering/vghwserialiser/src/serializedfunctioncall.cpp Wed Sep 29 09:49:13 2010 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,495 +0,0 @@ -// 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(&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 ) - { - }