// Copyright (c) 2006-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 "mmruf.h"

#include <e32uid.h>

#include "constants.h"

#include "parsers.h"

#ifdef _DEBUG

_LIT(KRUFPanic, "MMRUF");

static const TInt KReasonNoFunction = 1;

#endif

//

// A table of recognised file formats.

// It should be sorted in order of format popularity.

//

static const TSignature KSigs[] =

	{

	CUSTOM_SIG(KMimeAAC,		TAACParser::DoRecognise),

	CUSTOM_SIG(KMimeMP3,		TMP3Parser::DoRecognise),

	CUSTOM_SIG(KMimeMP4_V,		TMPEG4Parser::DoRecognise),

	CUSTOM_SIG(KMimeWMV,		TASFParser::DoRecognise),

	CUSTOM_SIG(KMimeMPEG2_V,	TMPEG2Parser::DoRecognise),

	CUSTOM_SIG(KMimeRM_V,		TRMParser::DoRecognise),

	CUSTOM_SIG(KMimeRAM,		TRAMParser::DoRecognise),

	CUSTOM_SIG(KMimeSDP,		TSDPParser::DoRecognise),

	CUSTOM_SIG(KMimeXPS,		TXPSParser::DoRecognise),

	HEADER_SIG(KMimeRA,			KExtRA,			KSigRA),

	HEADER_SIG(KMimeAIFF,		KExtAIFF_1,		KSigAIFF),

	HEADER_SIG(KMimeAIFF,		KExtAIFF_2,		KSigAIFF),

	HEADER_SIG(KMimeAIFF,		KExtAIFF_3,		KSigAIFF),

	HEADER_SIG(KMimeAMR,		KExtAMR,		KSigAMR_1),

	HEADER_SIG(KMimeAMR,		KExtAMR,		KSigAMR_2),

	HEADER_SIG(KMimeAMRWB,		KExtAMRWB,		KSigAMRWB_1),

	HEADER_SIG(KMimeAMRWB,		KExtAMRWB,		KSigAMRWB_2),

	HEADER_SIG(KMimeAU,			KExtAU,			KSigAU),

	HEADER_SIG(KMimeAVI,		KExtAVI,		KSigAVI),

	HEADER_SIG(KMimeDIVX,		KExtDIVX,		KSigDIVX_1),

	HEADER_SIG(KMimeDIVX,		KExtDIVX,		KSigDIVX_2),

	HEADER_SIG(KMimeDLS,		KExtDLS,		KSigDLS),

	HEADER_SIG(KMimeFLAC,		KExtFLAC_1,		KSigFLAC),

	HEADER_SIG(KMimeFLAC,		KExtFLAC_2,		KSigFLAC),

	HEADER_SIG(KMimeGSM,		KExtGSM,		KSigGSM),

	HEADER_SIG(KMimeM3U,		KExtM3U,		KSigM3U),

	HEADER_SIG(KMimeMID,		KExtMID,		KSigMID),

	HEADER_SIG(KMimeMLD,		KExtMLD,		KSigMLD),

	HEADER_SIG(KMimeMMF,		KExtMMF,		KSigMMF),

	HEADER_SIG(KMimeMXMF,		KExtMXMF,		KSigMXMF),

	HEADER_SIG(KMimeOGG,		KExtOGG,		KSigOGG),

	HEADER_SIG(KMimeBeatnikRMF, KExtBeatnikRMF, KSigBeatnikRMF),

	HEADER_SIG(KMimeSMF,		KExtSMF,		KSigSMF),

	HEADER_SIG(KMimeSND,		KExtSND,		KSigSND),

	HEADER_SIG(KMimeWAV,		KExtWAV,		KSigWAV_1),

	HEADER_SIG(KMimeWAV,		KExtWAV,		KSigWAV_2),

	HEADER_SIG(KMimeXMF,		KExtXMF,		KSigXMF),

	CUSTOM_SIG(KMimeMAT_V,		TMatroskaParser::DoRecognise),

	};

static const TInt KDataTypesCount = sizeof(KSigs) / sizeof(TSignature);

//

// Map all combinations of [ext_match][header_match] to confidence levels.

//

static const TInt KResultToConfidence[] =

	{

	KConfNotRecognised,

	KConfProbable,

	KConfPossible,

	KConfCertain

	};

//

//

//

const TImplementationProxy ImplementationTable[] =

	{

	// UID taken from Multimedia's UID allocation table.

	IMPLEMENTATION_PROXY_ENTRY(KRecogniserUID, CMMRUF::NewL)

	};

//

//

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

//

//

//

CMMRUF::CMMRUF()

 : CApaDataRecognizerType(KMMRUFDLLUid, KRecogniserPriority)

	{

	iCountDataTypes = KDataTypesCount;

	}

//

//

//

CMMRUF* CMMRUF::NewL()

	{

	return new(ELeave)CMMRUF();

	}

//

//

//

CMMRUF::~CMMRUF()

	{

	}

//

//

//

TUint CMMRUF::PreferredBufSize()

	{

	return KPreferredBufSize;	

	}

//

// Required for CApaDataRecognizerType parent class.

// It creates a mime-type string for the signature at aIndex.

//

TDataType CMMRUF::SupportedDataTypeL(TInt aIndex) const

	{

	if ((aIndex < 0) || (aIndex >= KDataTypesCount))

		{

		User::Leave(KErrArgument);

		}

	return SupportedDataTypeL(KSigs[aIndex].iMime);

	}

//

//

//

TDataType CMMRUF::SupportedDataTypeL(const TText8* aMime) const

	{

	if (aMime == NULL)

		{

		User::Leave(KErrArgument);

		}

	return TDataType(TPtrC8(aMime));

	}

//

// Records the matched data type and the confidence.

//

void CMMRUF::SetDataTypeL(TInt aConfidence, const TText8* aMime)

	{

	iDataType = SupportedDataTypeL(aMime);

	iConfidence = aConfidence;

	}

//

// Utility function for matching file extensions.

// Returns 1 if the extensions match, 0 otherwise.

//

TUint8 CMMRUF::MatchExtension(const TDesC& aFileExt, const TText* aKnownExt) const

	{

	if (aFileExt.Length() > 0)

		{

		return ((aFileExt.MatchF(TPtrC(aKnownExt)) != KErrNotFound) ? 1 : 0);

		}

	return 0;

	}

//

// Utility function for matching known header data.

// Returns 1 if the buffer contents match the header, 0 otherwise.

//

TUint8 CMMRUF::MatchHeader(const TDesC8& aBuffer, const TDesC8& aHeader) const

	{

	if (aBuffer.Length() > 0)

		{

		if (aHeader.Length() <= aBuffer.Length())

			{

			return ((aBuffer.Match(aHeader) != KErrNotFound) ? 1 : 0);

			}

		}

	return 0;

	}

//

// This function is called by AppArc when something needs recognising.

//

void CMMRUF::DoRecognizeL(const TDesC& aFileName, const TDesC8& aBuffer)

	{

	TMatch match;

	RArray<TMatch> matches;

	CleanupClosePushL(matches);

	// If a handle to the file is available, AppArc prepends "::" to the

	// aFileName parameter for some reason. This causes TParse to fail

	// to get the file extension, so we have to fix it.

	TPtrC fName(aFileName);

	if (aFileName.Match(_L("::*")) == 0)

 		{

		fName.Set(aFileName.Mid(2));

 		}

 	TParse parse;

	User::LeaveIfError(parse.Set(fName, NULL, NULL));

	const TPtrC& ext = parse.Ext();

	RFile* pFile = FilePassedByHandleL();

	CReader* pReader = (pFile ? CFileReader::NewLC(pFile) : CBufferReader::NewLC(aBuffer));

	// The main recognition loop.

	TBool certainMatch = EFalse;

	for (TInt i = 0; (i < KDataTypesCount) && !certainMatch; i++)

		{

		// Reset the results for each iteration.

		pReader->Reset();

		match.Reset();

		if (KSigs[i].iHeaderLen == 0)

			{

			// Call the custom recognition function.

			// match contains the results.

			__ASSERT_DEBUG(KSigs[i].iHeaderOrProc, User::Panic(KRUFPanic, KReasonNoFunction));

			TCustomProc proc = (TCustomProc)(KSigs[i].iHeaderOrProc);

			proc(ext, *pReader, match);

			}

		else

			{

			// This format has a known signature.

			TPtrC8 header(_S8(KSigs[i].iHeaderOrProc), KSigs[i].iHeaderLen);

			TUint8 sameHeader = MatchHeader(aBuffer, header);

			TUint8 sameExt = MatchExtension(ext, KSigs[i].iExt);

			TUint8 confIndex = MAKE_BYTE2(sameExt, sameHeader);

			match.iConfidence = KResultToConfidence[confIndex];

			match.iMime = KSigs[i].iMime; 

			}

		// Evaluate the result.

		switch (match.iConfidence)

			{

			case KConfNotRecognised:

				continue;

			case KConfCertain:

				certainMatch = ETrue;

				// Deliberate fall through to add match to array of matches.

			case KConfProbable:

				// Add it to the start of the array.

				User::LeaveIfError(matches.Insert(TMatch(match), 0));

				break;

			case KConfPossible:

				// Add it to the end of the array.

				if (matches.Count() == 0)

					{

					User::LeaveIfError(matches.Append(TMatch(match)));

					}

				break;

			default:

				// Should never get here.

				User::Leave(KErrArgument);

			}

		}	// for (TInt i = 0; i < KDataTypesCount; i++)

	// We've done looping.

	if (matches.Count() > 0)

		{

		match = matches[0];

		SetDataTypeL(match.iConfidence, match.iMime);

		}

	CleanupStack::PopAndDestroy(pReader);

	CleanupStack::PopAndDestroy(&matches);

	}