//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");
	}