// 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 "constants.h"

#include "parsers.h"

#define KASFAudioMedia				"\xF8\x69\x9E\x40\x5B\x4D\x11\xCF\xA8\xFD\x00\x80\x5F\x5C\x44\x2B"

#define KASFVideoMedia				"\xBC\x19\xEF\xC0\x5B\x4D\x11\xCF\xA8\xFD\x00\x80\x5F\x5C\x44\x2B"

#define KASFHeaderObject 			"\x75\xB2\x26\x30\x66\x8E\x11\xCF\xA6\xD9\x00\xAA\x00\x62\xCE\x6C"

#define KASFStreamPropertiesObject	"\xB7\xDC\x07\x91\xA9\xB7\x11\xCF\x8E\xE6\x00\xC0\x0C\x20\x53\x65"

#define KASFCodecListObject			"\x86\xD1\x52\x40\x31\x1D\x11\xD0\xA3\xA4\x00\xA0\xC9\x03\x48\xF6"

static const TInt KGUIDLen = 16; 				// 128-bit

static const TInt KObjectLen = KGUIDLen + 8; 	// GUID followed by 64-bit size.

static const TInt KMinObjectLen = 30; 			// From documentation

typedef struct

	{

	const TText* iExt;

	const TText8* iVideoMime;

	const TText8* iAudioMime;

	}

TASFType;

//

// Various ASF container MIME-types.

//

static const TASFType KASFTypes[] =

	{

		{KExtWMA,	KMimeWMA,	KMimeWMA},

		{KExtWMV,	KMimeWMV,	KMimeWMV},

		{KExtASF,	KMimeASF_V,	KMimeASF_A}

	};

#define KASFTypesCount	sizeof(KASFTypes) / sizeof(TASFType)

#define KASFHeaderObjectBit		KBit1	// 00000001

#define KASFStreamHeaderBit		KBit2	// 00000010

#define KASFVideoBit			KBit3	// 00000100

#define KASFConfidenceMask		0x07	// 00000111

//

// Flags mapped to confidence levels.

//

// A: Extension identified.

// B: HeaderObject GUID

// C: StreamProperties GUID

//

// C B A -> Confidence

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

// 0 0 0 -> ENotRecognised

// 0 0 1 -> EPossible

// 0 1 0 -> EPossible

// 0 1 1 -> EProbable

// 1 0 0 -> ENotRecognised (StreamProperties occurs within HeaderObject)

// 1 0 1 -> ENotRecognised (StreamProperties occurs within HeaderObject)

// 1 1 0 -> EProbable

// 1 1 1 -> ECertain

//

static const TInt KASFFlagsToConfidence[8] = 

	{

	KConfNotRecognised,

	KConfPossible,

	KConfPossible,

	KConfProbable,

	KConfNotRecognised,

	KConfNotRecognised,

	KConfProbable,

	KConfCertain

	};

//

//

//

TASFParser::TASFParser(CReader& aReader, TFlags& aFlags)

 :	iReader(aReader),

 	iFlags(aFlags)

	{

	}

//

// Sets the mime-type the file extension implies.

//

const TText8* TASFParser::MatchExtension(const TDesC& aExt, TBool aVideo)

	{

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

		{

		if (aExt.MatchF(TPtrC(KASFTypes[i].iExt)) != KErrNotFound)

			{

			return (aVideo ? KASFTypes[i].iVideoMime : KASFTypes[i].iAudioMime);

			}

		}

	return NULL;

	}

//

//

//

void TASFParser::DoRecognise(const TDesC& aExt, CReader& aReader, TMatch& aMatch)

	{

	TFlags flags;

	TASFParser parser(aReader, flags);

	// We need to parse first to determine if there's video content present.

	TRAPD(err, parser.ParseL());

	if (err == KErrCorrupt)

		{

		// Unrecognised content. However the extension may allow

		// correct identification so assume there's video content.

		flags.SetBit(KASFVideoBit);

		}

	const TText8* extMime = parser.MatchExtension(aExt, flags.GetBitField(KASFVideoBit));

	if (extMime != NULL)

		{

		// The extension was recognised.

		flags.SetExtensionFlag();

		}

	TInt confIndex = flags.GetBitField(KASFConfidenceMask);

	aMatch.iConfidence = KASFFlagsToConfidence[confIndex];

	if (aMatch.iConfidence != KConfNotRecognised)

		{

		// Trust the mime-type the extension maps to.

		// If the extension wasn't recognised, but the content was

		// then return the generic ASF mime type. ASF format files

		// can't be identified from their content; just whether they

		// contain video or not.

		aMatch.iMime = extMime;

		if (aMatch.iMime == NULL)

			{

			aMatch.iMime = (flags.GetBitField(KASFVideoBit) ? KMimeASF_V : KMimeASF_A);

			}

		}

	}

//

//

//

void TASFParser::ParseL()

	{

	// ASF files are logically composed of three types of top-level objects:

	// the Header Object, the Data Object, and the Index Object(s).

	// The Header Object is mandatory and must be placed at the beginning of every

	// ASF file. The Data Object is also mandatory and must follow the Header Object.

	// The Index Object(s) are optional, but they are useful in providing time-based

	// random access into ASF files. When present, the Index Object(s) must be the

	// last object in the ASF file. 

	TBuf8<KGUIDLen> guid;

	TInt64 size;

	const TBool useLittleEndian = ETrue;

	// Assume there's video content present if we only have buffer data.

	if (iReader.Type() == CReader::EBuffer)

		{

		iFlags.SetBit(KASFVideoBit);

		}

	ReadObjectL(guid, size);

	if (guid == MAKE_TPtrC8(KASFHeaderObject))

		{

		TUint32 objectCount;

		if (size < KMinObjectLen)

			{

			User::Leave(KErrCorrupt);

			}

		iFlags.SetBit(KASFHeaderObjectBit);

		// We need to find out how many objects there are.

		iReader.Read32L(objectCount, useLittleEndian);

		iReader.SeekL(2); // Ignore reserved values (two bytes).

		const TDesC8& streamPropertiesGUID = MAKE_TPtrC8(KASFStreamPropertiesObject);

		const TDesC8& videoMediaGUID = MAKE_TPtrC8(KASFVideoMedia);

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

			{

			ReadObjectL(guid, size);

			// We want the stream properties object.

			if (guid == streamPropertiesGUID)

				{

				// There may be more than one present.

				iFlags.SetBit(KASFStreamHeaderBit);

				ReadGUIDL(guid);

				if (guid == videoMediaGUID)

					{

					iFlags.SetBit(KASFVideoBit);

					}

				iReader.SeekL(size - KObjectLen - KGUIDLen);

				}

			else

				{

				iReader.SeekL(size - KObjectLen);

				}

			}

		}

	else

		{

		User::Leave(KErrCorrupt);

		}

	}

//

//

//

void TASFParser::ReadObjectL(TDes8& aGUID, TInt64& aSize)

	{

	//The base unit of organization for ASF files is called the ASF object.

	//It consists of a 128-bit GUID for the object, a 64-bit integer object size,

	//and the variable-length object data. The value of the object size field is

	//the sum of 24 bytes plus the size of the object data in bytes.

	TUint32 word1;

	TUint32 word2;

	const TBool useLittleEndian = ETrue;

	aGUID.SetLength(KGUIDLen);

	ReadGUIDL(aGUID);

	iReader.Read32L(word2, useLittleEndian);

	iReader.Read32L(word1, useLittleEndian);

	aSize = MAKE_TINT64(word1, word2);

	}

//

//

//

void TASFParser::ReadGUIDL(TDes8& aGUID)

	{

	TUint8 byte;

	if (aGUID.Length() != KGUIDLen)

		{

		User::Leave(KErrUnderflow);

		}

	// Parts of the GUID are stored in big-endian order.

	// They're converted to little-endian order here.

	iReader.ReadByteL(byte);	aGUID[3] = byte;

	iReader.ReadByteL(byte);	aGUID[2] = byte;

	iReader.ReadByteL(byte);	aGUID[1] = byte;

	iReader.ReadByteL(byte);	aGUID[0] = byte;

	iReader.ReadByteL(byte);	aGUID[5] = byte;

	iReader.ReadByteL(byte);	aGUID[4] = byte;

	iReader.ReadByteL(byte);	aGUID[7] = byte;

	iReader.ReadByteL(byte);	aGUID[6] = byte;

	for (TInt i = 8; i < KGUIDLen; i++)

		{

		iReader.ReadByteL(byte);

		aGUID[i] = byte; 

		}

	}