// 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"

//

// Matroska 'XML' tags.

//

static const TUint32 KEBML = 0x1A45DFA3;

static const TUint32 KSegment = 0x18538067;

static const TUint32 KTracks = 0x1654AE6B;

static const TUint32 KTrackEntry = 0xAE;

static const TUint32 KTrackType = 0x83;

static const TUint32 KVoid = 0xEC;

static const TUint32 KSeekHead = 0x114D9B74;

static const TUint32 KSegmentInfo = 0x1549A966;

static const TUint32 KCluster = 0x1F43B675;

static const TUint32 KCues = 0x1C53BB6B;

static const TUint32 KAttachments = 0x1941A469;

static const TUint32 KChapters = 0x1043A770;

static const TUint32 KTags = 0x1254C367;

//

// Matroska Track Types.

//

static const TUint8 KTrackTypeVideo = 0x01;

#define KMatroskaConfidenceMask	0x07	// 00000111

#define KMatroskaEBMLBit		KBit1

#define KMatroskaSegmentBit		KBit2

#define KMatroskaVideoBit		KBit3

//

// This truth table maps the following flags to confidence levels.

//

// A: Extension match.

// B: EBML tag found.

// C: Segment tag found.

//

// C B A -> Confidence

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

// 0 0 0 -> NotRecognised

// 0 0 1 -> EPossible

// 0 1 0 -> EPossible

// 0 1 1 -> EProbable

// 1 0 0 -> ENotRecognised (EBML should be present)

// 1 0 1 -> ENotRecognised (EBML should be present)

// 1 1 0 -> EProbable

// 1 1 1 -> ECertain

//

static const TInt KMatroskaFlagsToConfidence[8] =

	{

	KConfNotRecognised,

	KConfPossible,

	KConfPossible,

	KConfProbable,

	KConfNotRecognised,

	KConfNotRecognised,

	KConfProbable,

	KConfCertain

	};

static const TInt KMatExtensionOnlyIndex = 1; // See truth table.

typedef struct

	{

	const TText* iExt;

	const TText8* iMime;

	}

TMatroskaExt;

//

// Known Matroska extensions and their corresponding MIME-types.

//

static const TMatroskaExt KMatroskaExt[] =

	{

		{KExtMAT_A, KMimeMAT_A },

		{KExtMAT_V, KMimeMAT_V }

	};

static const TInt KMatroskaExtCount = sizeof(KMatroskaExt) / sizeof(TMatroskaExt);

//

//

//

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

 :	iReader(aReader),

 	iFlags(aFlags)

	{

	}

//

//

//

const TText8* TMatroskaParser::MatchExtension(const TDesC& aExt)

	{

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

		{

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

			{

			return KMatroskaExt[i].iMime;

			}

		}

	return NULL;

	}

//

// This function calls the parser and turns the results

// into a MIME-type.

//

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

	{

	TFlags flags;

	TMatroskaParser parser(aReader, flags);

	// Try to match the extension.

	const TText8* extMime = parser.MatchExtension(aExt);

	if (extMime != NULL)

		{

		flags.SetExtensionFlag();

		}

	// Try to parse the content.

	TRAP_IGNORE(parser.ParseL());

	TInt confIndex = flags.GetBitField(KMatroskaConfidenceMask);

	aMatch.iConfidence = KMatroskaFlagsToConfidence[confIndex];

	if (aMatch.iConfidence != KConfNotRecognised)

		{

		// If any header data has been recognised trust that,

		// otherwise go with the extension.

		if (confIndex == KMatExtensionOnlyIndex)

			{

			aMatch.iMime = extMime;

			}

		else

			{

			aMatch.iMime = (flags.GetBitField(KMatroskaVideoBit) ? KMimeMAT_V : KMimeMAT_A);

			}

		}

	}

//

// This function does the parsing.

//

void TMatroskaParser::ParseL()

	{

	TUint64 id;

	TInt64 size;

	TBool haveElement = EFalse;

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

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

		{

		iFlags.SetBit(KMatroskaVideoBit);

		}

	FOREVER

		{

		if (!haveElement)

			{

			ReadElementL(id, size);

			}

		switch (id)

			{

			case KEBML:

				iFlags.SetBit(KMatroskaEBMLBit);

				break;

			case KSegment:

				haveElement = ReadSegmentL(id, size);

				break;

			default:

				// Skip it.

				iReader.SeekL(size);

			}

		}

	}

//

// This function returns ETrue if the aNextID and aNextSize parameters

// contain valid values, EFalse otherwise.

//

TBool TMatroskaParser::ReadSegmentL(TUint64& aNextID, TInt64& aNextSize)

	{

	TUint64 id;

	TInt64 size;

	TBool videoContent = EFalse;

	aNextID = 0;

	aNextSize = 0;

	iFlags.SetBit(KMatroskaSegmentBit);

	while (!videoContent)

		{

		ReadElementL(id, size);

		switch (id)

			{

			case KTracks:

				videoContent = ReadTrackL(size);

				break;

			case KSeekHead:

			case KSegmentInfo:

			case KCluster:

			case KCues:

			case KAttachments: 

			case KChapters:

			case KTags:

				iReader.SeekL(size);

				break;

			default:

				// Unrecognised element id. Pass it back to the caller

				aNextID = id;

				aNextSize = size;

				return ETrue;

			}

		}

	// Tell the caller they must read the next element themselves.

	return EFalse;

	}

//

// The Track. This lets us know if there's video content present.

//

TBool TMatroskaParser::ReadTrackL(TInt64 aTrackSize)

	{

	TUint64 id;

	TInt64 size;

	TInt startPos = iReader.Position();

	while (iReader.Position() - startPos < aTrackSize)

		{

		ReadElementL(id, size);

		switch (id)

			{

			case KTrackEntry:

				break;

			case KTrackType:

				TUint8 trackType;

				iReader.ReadByteL(trackType);

				if (trackType == KTrackTypeVideo)

					{

					// We found video content so we can stop parsing.

					iFlags.SetBit(KMatroskaVideoBit);

					return ETrue;

					}

				break;

			default:

				iReader.SeekL(size);

			}

		}

	return EFalse;

	}

//

//

//

void TMatroskaParser::ReadElementL(TUint64& aElementID, TInt64& aSize)

	{

	do

		{

		aElementID = ReadDataL();

		aSize = ReadDataL(ETrue);

		// Void elements are used for padding and

		// can be ignored.

		if (aElementID == KVoid)

			{

			iReader.SeekL(aSize);

			}

		}

	while (aElementID == KVoid);

	}

//

//

//

TUint64 TMatroskaParser::ReadDataL(TBool aTurnOffHighestSetBit)

	{

	TUint64 retval;

	TUint8 byte;

	TUint8 mask = 0x80; // [1000 0000]. It will be shifted right 1 in each 'i' iteration.

	TUint8 size = 1;	// It will be incremented in each 'i' iteration.

	iReader.ReadByteL(byte);

	for (TInt i = 0; i < sizeof(TUint64); i++)

		{

		if (byte & mask)

			{

			retval = byte;

			if (aTurnOffHighestSetBit)

				{

				retval &= ~mask; // Turn off the highest set bit.

				}

			// Now read the real data.

			// Start from 1 because we've already read a byte.

			for (TInt j = 1; j < size; j++)

				{

				iReader.ReadByteL(byte);

				retval <<= 8;

				retval |= byte;

				}

			return retval;

			}

		else

			{

			mask >>= 1;

			size++;

			}

		}

	User::Leave(KErrCorrupt);

	return 0; // Keep the compiler happy.

	}