//a3ffourcclookup.cpp

// Copyright (c) 2007-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 <a3f/a3ffourcclookup.h>

#include "a3ffourcclookup.hrh"

#include <a3f/a3f_trace_utils.h>

#include <mm/mmcleanup.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <a3f/a3f_trace_ctxt_def.h>

#endif

_LIT8(KHexPrefix, "0x");

_LIT8(KHexPrefix2, "0X");

_LIT8(uTag,"<u>");

_LIT8(mTag,"<m>");

_LIT8(fTag,"<f>");

const TInt KUidLength = 10;

const TInt KTagLength = 3;

const TInt KFourCCLength = 4;

// ---------------------------------------------------------------------------

// Function to compute Hash value

// ---------------------------------------------------------------------------

TUint32 TIntegerHash(const TUint32& aInt)

	{

	return DefaultHash::Integer(aInt);

	}

// ---------------------------------------------------------------------------

// Function to Check similar identities from Hash Table

// ---------------------------------------------------------------------------

TBool TIntegerIdent(const TUint32& /*aL*/, const TUint32& /*aR*/)

	{

	return ETrue;

	}

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

CFourCCConvertor::~CFourCCConvertor()

	{

	if(iHashFourCCToFormat)

		{

		iHashFourCCToFormat->Close();

		delete iHashFourCCToFormat;		

		iHashFourCCToFormat = NULL;

		}

	if(iHashFormatToFourCC)

		{

		iHashFormatToFourCC->Close();	

		delete iHashFormatToFourCC;

		iHashFormatToFourCC = NULL;

		}	

	}

// ---------------------------------------------------------------------------

// Default constructor

// ---------------------------------------------------------------------------

CFourCCConvertor::CFourCCConvertor()

	{

	TRACE_CREATE();

	DP_CONTEXT(CFourCCConvertor::CFourCCConvertor *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CFourCCConvertor::NewL

// ---------------------------------------------------------------------------

EXPORT_C CFourCCConvertor* CFourCCConvertor::NewL()

	{

	DP_STATIC_CONTEXT(CFourCCConvertor::NewL *CD0*, CtxDevSound, DPLOCAL);

	DP_IN();

	CFourCCConvertor* self = new(ELeave) CFourCCConvertor();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	DP0_RET(self, "0x%x");

	}

// ---------------------------------------------------------------------------

// Second Phase Constructor

// ---------------------------------------------------------------------------

void CFourCCConvertor::ConstructL()

	{

	DP_CONTEXT(CCFourCCConvertor::ConstructL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iHashFourCCToFormat = new(ELeave) RHashMap<TUint32,TUint32>(&TIntegerHash,&TIntegerIdent);

	iHashFormatToFourCC = new(ELeave) RHashMap<TUint32,TUint32>(&TIntegerHash,&TIntegerIdent);

	LoadL();

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CFourCCConvertor::LoadL

// ---------------------------------------------------------------------------

void CFourCCConvertor::LoadL()

	{

	DP_CONTEXT(CCFourCCConvertor::LoadL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TUid KFourCCInterfaceDefinitionUid = {KUidA3fFourCCConvertorPlugin};

	RImplInfoPtrArray ecomArray;

	REComSession::ListImplementationsL(KFourCCInterfaceDefinitionUid, ecomArray);

	CleanupResetAndDestroyPushL(ecomArray);

	ASSERT(iHashFourCCToFormat);

	ASSERT(iHashFormatToFourCC);

	TInt index;

	index = ecomArray.Count();

	if(index == 0)

		{

		User::Leave(KErrNotFound);

		}

	TInt tagPosition=0;

	TUint32 formatIdValue = 0;

	// Construct the hash map

	for (TInt i=0; i<index; i++)

		{

		// Get opaque data field

		const TPtrC8 opaquedata(ecomArray[i]->OpaqueData());

		TInt length = opaquedata.Length();

		// Extracting format uid

		tagPosition = opaquedata.Find(uTag);

		if( (tagPosition >= 0) && ( (length-tagPosition) >= (KUidLength + KTagLength) ) )

			{

			// Format Uid

			if(((((opaquedata).Mid(tagPosition + KTagLength, KUidLength) ).Length()) == KUidLength) &&

				((((opaquedata).Mid(tagPosition + KTagLength, KUidLength)).Find(KHexPrefix)) ==0) ||

				((((opaquedata).Mid(tagPosition + KTagLength, KUidLength)).Find(KHexPrefix2)) ==0))

				{

				TLex8 lexFormatUid(((opaquedata).Mid(tagPosition + KTagLength, KUidLength)).Right(8));

				User::LeaveIfError(lexFormatUid.Val(formatIdValue,EHex));

				}

			// Check if this is master FourCC

			TInt tagMasterFourCC=0;

			tagMasterFourCC= (opaquedata).Find(mTag);

			// Extract fourCC

			tagPosition = (opaquedata).Find(fTag);

			if((tagPosition >=0) && (length-tagPosition>=(KFourCCLength + KTagLength)))

				{

				TFourCC tempFourCC((opaquedata).Mid(tagPosition + KTagLength, KFourCCLength));

				if(tempFourCC.FourCC() != 0)

					{

					iHashFourCCToFormat->InsertL(tempFourCC.FourCC(),formatIdValue); 

					}

				// Only fourCC master should be inserted

				if(tagMasterFourCC >= 0)

					{

					iHashFormatToFourCC->InsertL(formatIdValue, tempFourCC.FourCC());

					}

				}

			else

				{

				DP0(DLINFO,"CCFourCCConvertor::<f> tag not found or <f> tag should have four characters entry in resource file ");	

				}

			}

		else

			{

			DP0(DLINFO,"CCFourCCConvertor::<u> tag not found or <u> tag should have ten characters e.g. 0X12122121 entry in resource file");

			}

		}

	CleanupStack::PopAndDestroy(&ecomArray);

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CFourCCConvertor::FormatToFourCC

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CFourCCConvertor::FormatToFourCC(TUid aFormat,TFourCC &aFourCC)

	{

	DP_CONTEXT(CCFourCCConvertor::FormatToFourCC *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(iHashFormatToFourCC);

	TInt err = KErrNone;

	TUint32 *mime = iHashFormatToFourCC->Find(aFormat.iUid);

	if(mime == NULL)

		{

		err = KErrNotFound;

		}

	else

		{

		aFourCC.Set(*mime);

		}

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CFourCCConvertor::FourCCToFormat

// ---------------------------------------------------------------------------

EXPORT_C TInt CFourCCConvertor::FourCCToFormat(TFourCC aFourCC, TUid &aFormat) const

	{

	DP_CONTEXT(CCFourCCConvertor::FourCCToFormat *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(iHashFourCCToFormat);

	TInt err = KErrNone;

	TUint32 *mime= iHashFourCCToFormat->Find(aFourCC.FourCC());

	if(mime == NULL)

		{

		err = KErrNotFound;

		}

	else

		{

		aFormat.iUid = *mime;

		}

	DP0_RET(err, "%d");

	}