diff -r 000000000000 -r bde4ae8d615e os/mm/mmdevicefw/mdf/src/codecapi/codecapiresolverutils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmdevicefw/mdf/src/codecapi/codecapiresolverutils.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,304 @@ +// Copyright (c) 2005-2009 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 +#include "codecapiresolverconsts.h" + + +/** + Creates a new CCodecApiOpaqueData object. + @param aOpaqueData + A reference to the opaque data value. + @return A pointer to the newly constructed match data object. + */ +EXPORT_C CCodecApiOpaqueData* CCodecApiOpaqueData::NewL(const TDesC8& aOpaqueData) + { + CCodecApiOpaqueData* result = CCodecApiOpaqueData::NewLC(aOpaqueData); + CleanupStack::Pop(result); + return result; + } + + +/** + Creates a new CCodecApiOpaqueData object and leaves a pointer to it on the cleanup stack. + @param aOpaqueData + A reference to the opaque data value. + @return A pointer to the newly constructed match data object. + */ +EXPORT_C CCodecApiOpaqueData* CCodecApiOpaqueData::NewLC(const TDesC8& aOpaqueData) + { + CCodecApiOpaqueData* result = new (ELeave) CCodecApiOpaqueData(aOpaqueData); + CleanupStack::PushL(result); + result->ConstructL(); + return result; + } + + +/** + Constructor. + @param aOpaqueData + A reference to the opaque data value. + */ +CCodecApiOpaqueData::CCodecApiOpaqueData(const TDesC8& aOpaqueData) : + iOpaqueData(aOpaqueData) + { + } + +/** + Sets up the data inside the class by calling ParseTaggedDataL(). + */ +void CCodecApiOpaqueData::ConstructL() + { + ParseTaggedDataL(); + } + + +/** + Destructor. + */ +CCodecApiOpaqueData::~CCodecApiOpaqueData() + { + delete iInputDataFormat; + delete iOutputDataFormat; + } + +/* + Parses the opaque data and calls ProcessTaggedDataL() to set the + data member of the class. + */ +void CCodecApiOpaqueData::ParseTaggedDataL() + { + TInt readPosition = 0; + TBool moreData = (iOpaqueData.Length()>0) ? ETrue : EFalse; + while (moreData) + { + // Assume that this segment will begin with a tag + TPtrC8 restOfData = iOpaqueData.Mid(readPosition); + TInt endPos = restOfData.MatchF(KTagMatch); + if (endPos == KErrNotFound) + { + User::Leave(KErrCorrupt); + } + // Extract the tag + TPtrC8 tag = restOfData.Left(KTagLength); + readPosition += KTagLength; + // Find the next tag + restOfData.Set(iOpaqueData.Mid(readPosition)); + endPos = restOfData.MatchF(KTagMatch); + TPtrC8 tagData; + if (endPos == KErrNotFound) + { + // If we didn't find a tag, we must be at the end of the data + tagData.Set(restOfData); + readPosition = restOfData.Length(); + moreData = EFalse; + } + else + { + tagData.Set(restOfData.Left(endPos)); + readPosition += endPos; + } + ProcessTaggedDataL(tag, tagData); + } + } + + + +/** + Sets member data to the value of the given opaque data, based upon the tag value provided. + @param aTag + A constant reference to a tag from the opaque data. Can be \, \ and \. + @param aData + The data associated with a tag. + */ +void CCodecApiOpaqueData::ProcessTaggedDataL(const TDesC8& aTag, const TDesC8& aData) + { + if (aTag==KMediaUid) + { + SetMediaUidL(aData); + return; + } + if (aTag==KInputPortFormat) + { + HBufC8* dataFormat = aData.AllocL(); + delete iInputDataFormat; + iInputDataFormat = dataFormat; + return; + } + if (aTag==KOutputPortFormat) + { + HBufC8* dataFormat = aData.AllocL(); + delete iOutputDataFormat; + iOutputDataFormat = dataFormat; + return; + } + User::Leave(KErrCorrupt); + } + + +/** + Sets the value of the media UID data. + @param aData + The value to set the media uid to. + */ +void CCodecApiOpaqueData::SetMediaUidL(const TDesC8& aData) + { + ConvertTextToUidL(aData, iTypeUid); + } + + +/** + Converts a given string to an integer. + @param aData + The value to be converted. + @return The converted value + */ +TUint CCodecApiOpaqueData::ConvertTextToTUintL(const TDesC8& aData) + { + // Determine whether hex or decimal then parse as such + _LIT8(K0x, "0x"); + TInt lenHexMarker = K0x().Length(); + TUint value = 0; + + // simple white space left trim (only handles spaces) + int index = 0; + while (aData[index]==' ') + { + index++; + } + TPtrC8 data = aData.Mid(index); + if (((data.Left(lenHexMarker).CompareF(K0x) == 0)) && (data.Length() >= 3)) + { + // Only take the characters after "0x" + TLex8 lex(data.Mid(lenHexMarker)); + User::LeaveIfError(lex.Val(value, EHex)); + } + else if (data.Length() > 0) + { + TLex8 lex(data); + User::LeaveIfError(lex.Val(value, EDecimal)); + } + else + { + User::Leave(KErrCorrupt); + } + return value; + } + + +/** + Converts a given string to a UID. + @param aData + The value to be converted. + @param aData + The value after conversion. + */ +void CCodecApiOpaqueData::ConvertTextToUidL(const TDesC8& aData, TUid& aUid) + { + _LIT8(K0x, "0x"); + if ((aData.Length() == 10) && (aData.FindF(K0x) == 0)) + { + // only take the right 8 characters (ie discard the "0x") + TLex8 lex(aData.Right(8)); + TUint32 value = 0; + User::LeaveIfError(lex.Val(value, EHex)); + aUid.iUid = value; + } + else + { + User::Leave(KErrCorrupt); + } + } + + +/** + Returns the value of the type UID data member. + @return The value of the type UID data member. + */ +EXPORT_C TUid CCodecApiOpaqueData::TypeUid() const + { + return iTypeUid; + } + + +/** + Returns the value of the input data type. + @return The value of the input data type. + */ +EXPORT_C const TDesC8& CCodecApiOpaqueData::InputDataType() const + { + if (iInputDataFormat) + { + return *iInputDataFormat; + } + return KNullDesC8; + } + + +/** + Returns the value of the output data type. + @return The value of the output data type. + */ +EXPORT_C const TDesC8& CCodecApiOpaqueData::OutputDataType() const + { + if (iOutputDataFormat) + { + return *iOutputDataFormat; + } + return KNullDesC8; + } + + +/** + Compares the input data type with the argument of the method. + @param aDataType + The value to be compared to. + @return ETrue if the argument of the method and the input data + type are the same. + */ +EXPORT_C TBool CCodecApiOpaqueData::CompareInputDataType(const TDesC8& aDataType) + { + if(iInputDataFormat) + { + const TDesC8& i = *iInputDataFormat; + if(aDataType.CompareF(i) == 0) + { + return ETrue; + } + } + return EFalse; + } + + +/** + Compares the output data type with the argument of the method. + @param aDataType + The value to be compared to. + @return ETrue if the argument of the method and the output data + type are the same. + */ +EXPORT_C TBool CCodecApiOpaqueData::CompareOutputDataType(const TDesC8& aDataType) + { + if(iOutputDataFormat) + { + if(aDataType.CompareF(*iOutputDataFormat) == 0) + { + return ETrue; + } + } + return EFalse; + } + +