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

static const TUint32 KRMFileHeaderId = MAKE_INT32('.', 'R', 'M', 'F');

static const TUint32 KRMMediaPropertiesId = MAKE_INT32('M', 'D', 'P', 'R');

static const TInt KRMMaxMimeTypeLen = 255;	// Specified by an 8-bit field

#define KRMExtensionBit			KBit0

#define KRMFileHeaderBit		KBit1

#define KRMMediaPropertiesBit	KBit2

#define KRMVideoBit				KBit3

#define KRMVideoMask			0x08	// 0000 1000

#define KRMConfidenceMask 		0x07	// 0000 0111

//

// This truth table maps the following flags to a confidence level.

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

// A: MediaProperties chunk found

// B: FileHeader signature found

// C: Extension recognised.

//

// A B C -> Confidence

// ===================

// 0 0 0 -> ENotRecognized

// 0 0 1 -> EPossible

// 0 1 0 -> EPossible (EPossible beacuse the header is ASCII and may match plaintext)

// 0 1 1 -> ECertain

// 1 0 0 -> ENotRecognised (Can't have MediaProperties without FileHeader)

// 1 0 1 -> ENotRecognised (Can't have MediaProperties without FileHeader)

// 1 1 0 -> EProbable

// 1 1 1 -> ECertain

//

static const TInt KRMFlagsToConfidence[] =

	{

	KConfNotRecognised,

	KConfPossible,

	KConfPossible,

	KConfCertain,

	KConfNotRecognised,

	KConfNotRecognised,

	KConfProbable,

	KConfCertain

	};

//

// Constructor.

//

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

 :	iReader(aReader),

	iFlags(aFlags)

	{

	}

//

// The main RealMedia parsing function.

//

void TRMParser::DoRecognise(const TDesC& aFileExt, CReader& aReader, TMatch& aMatch)

	{

	TFlags flags;

	TRMParser parser(aReader, flags);

	parser.MatchExtension(aFileExt);

	TRAP_IGNORE(parser.ParseL());

	TInt confIndex = flags.GetBitField(KRMConfidenceMask);

	aMatch.iConfidence = KRMFlagsToConfidence[confIndex];

	if (aMatch.iConfidence != KConfNotRecognised)

		{

		aMatch.iMime = (flags.GetBitField(KRMVideoMask) ? KMimeRM_V : KMimeRM_A);

		}

	}

//

// Match the file extension given by AppArc against known

// extensions for this format.

//

void TRMParser::MatchExtension(const TDesC& aFileExt)

	{

	TBool match;

	match = (aFileExt.MatchF(TPtrC(KExtRMF)) != KErrNotFound);

	match |= (aFileExt.MatchF(TPtrC(KExtRM)) != KErrNotFound);

	if (match)

		{

		iFlags.SetExtensionFlag();

		}

	}

//

// RealMedia files are divided into chunks. Chunks begins with a 32-bit identifier

// which is followed by a 32-bit unsigned field that specifies the size of the chunk

// in bytes. Since the size field is unsigned, it must be cast to a TInt64 in order

// for SeekL() to work reliably. The size field also includes the length of the chunk

// identifier and the length of the size field itself, so these must be subtracted

// from any seek operation.

//

void TRMParser::ParseL()

	{

	TUint32 objectId;

	TUint32 size;

	const TInt KChunkHeaderSize = sizeof(TUint32) * 2; // sizeof objectId and size fields.

	// The first chunk must be the FileHeader.

	ReadChunkHeaderL(objectId, size, ETrue);

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

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

		{

		iFlags.SetBit(KRMVideoBit);

		}

	iReader.SeekL(TInt64(size - KChunkHeaderSize));

	// The other chunks can occur in any order.

	TBool complete = EFalse;

	do

		{

		ReadChunkHeaderL(objectId, size);

		if (objectId == KRMMediaPropertiesId)

			{

			iFlags.SetBit(KRMMediaPropertiesBit);

			if (ReadMediaPropertiesL())

				{

				// Exit early if the video flag has been set by ReadMediaPropertiesL.

				complete = ETrue;

				}

			}

		else

			{

			// Skip over the unneeded chunk.

			iReader.SeekL(TInt64(size - KChunkHeaderSize));

			}

		}

	while (!complete);

	}

//

// Reads the chunk identifier and size.

//

void TRMParser::ReadChunkHeaderL(TUint32& aObjectId, TUint32& aSize, TBool aFirstChunk)

	{

	iReader.Read32L(aObjectId);

	if (aFirstChunk)

		{

		if (aObjectId == KRMFileHeaderId)

			{

			iFlags.SetBit(KRMFileHeaderBit);

			}

		else

			{

			User::Leave(KErrCorrupt);

			}

		}

	iReader.Read32L(aSize);

	if (aSize == 0)

		{

		User::Leave(KErrCorrupt);

		}

	}

//

// The MediaProperties chunk describes a stream in the RM file. There

// may be several MediaProperties chunks in one file. In order to determine

// if video content is present we must look at the MIME-type that may

// be present in each MediaProperties chunk.

// Return ETrue if this function set the video bit.

//

TBool TRMParser::ReadMediaPropertiesL()

	{

	const TInt KBytesToFieldSize = 30;

	// ObjectId and size fields have already been read.

	TBool setVideo = EFalse;

	TUint16 objectVersion;

	iReader.Read16L(objectVersion);

	if (objectVersion == 0)

		{

		TUint8 fieldSize;

		TBuf8<KRMMaxMimeTypeLen> mimeType;

		_LIT8(KVideoStar, "video/*");

		// Skip unneeded information.

		iReader.SeekL(KBytesToFieldSize);

		// Read stream_name_size so we can skip over it.

		iReader.ReadByteL(fieldSize);

		iReader.SeekL(fieldSize);

		// Read the mime_type_size. Because it's 8-bit, it has a max length of 256 bytes.

		iReader.ReadByteL(fieldSize);

		mimeType.SetLength(fieldSize);

		iReader.ReadBytesL(mimeType);

		// Now check if the mime-type field indicates video content.

		if (mimeType.MatchF(KVideoStar) != KErrNotFound)

			{

			iFlags.SetBit(KRMVideoBit);

			setVideo = ETrue;

			}

		// Read the type_specific_len so we can skip over it.

		TUint32 typeSpecificLen;

		iReader.Read32L(typeSpecificLen);

		iReader.SeekL(TInt64(typeSpecificLen));

		}

	return setVideo;

	}