// 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 TUint8 KISOEndCode = 0xB9;

 static const TUint8 KPackStartCode = 0xBA;

 static const TUint8 KVideoElementaryStream = 0xE0;

 #define KMPEG1PackHeaderLen		8

 #define KMPEG2PackHeaderLen		10

 #define KMPEG1PackHeaderID		0x21	// 0010xxx1. See Doc Link 2.

 #define KMPEG2PackHeaderID		0x44	// 01xxx1xx. See Doc Link 2.

 #define KStartCodeMask			0xffffff00

 #define KStartCodeIntro			0x00000100

 #define KMPEG2StartCode1Bit	KBit1

 #define KMPEG2StartCode2Bit	KBit2

 #define KMPEG2VideoBit		KBit3

 #define KMPEG2MPEG1Bit		KBit4

 //

 // Mapping flags to a confidence level.

 //

 // A: extension match

 // B: start-code1

 // C: start-code2

 //

 // C B A -> Confidence

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

 // 0 0 0 -> ENotRecognised

 // 0 0 1 -> EPossible

 // 0 1 0 -> EPossible

 // 0 1 1 -> EProbable

 // 1 0 0 -> ENotRecognised

 // 1 0 1 -> ENotRecognised

 // 1 1 0 -> EProbable

 // 1 1 1 -> ECertain

 //

 static const TInt KMPEG2FlagsToConfidence[] =

 	{

 	KConfNotRecognised,

 	KConfPossible,

 	KConfPossible,

 	KConfProbable,

 	KConfNotRecognised,

 	KConfNotRecognised,

 	KConfProbable,

 	KConfCertain

 	};

 #define KMPEG2ConfidenceMask	0x07	// 00000111

 #define KMPEG2MimeMask	 		0x18	// 00011000

 #define KMPEG2MimeShift			0x03	

 static const TInt KMPEG2ExtOnlyIndex = 1;

 //

 // The 'ED' bits of the flags member are used as an index into

 // this table of possible MIME-types.

 //

 // E: MPEG1 instead of MPEG2

 // D: Video content present

 //

 // E D -> Mime

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

 // 0 0 -> audio/mpeg2

 // 0 1 -> video/mpeg2

 // 1 0 -> audio/mpeg1

 // 1 1 -> video/mpeg1

 //

 static const TText8* const KMPEG2Mimes[] = 

 	{

 	KMimeMPEG2_A,

 	KMimeMPEG2_V,

 	KMimeMPEG1_A,

 	KMimeMPEG1_V

 	};

 //

 // A list of known MPEG2 file extensions.

 // MPEG1 file extensions are also listed.

 //

 typedef struct

 	{

 	const TText* iExt;

 	const TText8* iMime;

 	}

 TMPEG2Types;

 static const TMPEG2Types KMPEG2Types[] = 

 	{

 		{ KExtMPEG_1, KMimeMPEG2_V },

 		{ KExtMPEG_2, KMimeMPEG2_V },

 		{ KExtMPEG_3, KMimeMPEG2_V },

 		{ KExtMPEG_4, KMimeMPEG2_V },

 		{ KExtMPEG_5, KMimeMPEG2_V },

 		{ KExtMPEG_6, KMimeMPEG2_V },

 		{ KExtMPEG_7, KMimeMPEG1_V },

 		{ KExtMPEG_8, KMimeMPEG2_A }

 	};

 #define KMPEG2ExtCount sizeof(KMPEG2Types) / sizeof(TMPEG2Types)

 //

 //

 //

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

  :	iReader(aReader),

  	iFlags(aFlags)

 	{

 	}

 //

 // Match the file's extension to known MPEG2 file extensions.

 //

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

 	{

 	if (aExt.Length() > 0)

 		{

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

 			{

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

 				{

 				iFlags.SetExtensionFlag();

 				return KMPEG2Types[i].iMime;

 				}

 			}

 		}

 	return NULL;

 	}

 //

 //

 //

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

 	{

 	TFlags flags;

 	TMPEG2Parser parser(aReader, flags);

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

 	TRAP_IGNORE(parser.ParseL());

 	TInt confIndex = flags.GetBitField(KMPEG2ConfidenceMask);

 	aMatch.iConfidence = KMPEG2FlagsToConfidence[confIndex];

 	if (aMatch.iConfidence != KConfNotRecognised)

 		{

 		if (confIndex == KMPEG2ExtOnlyIndex)

 			{

 			// The content is corrupt, but the extension was recognised.

 			aMatch.iMime = extMime;

 			}

 		else

 			{

 			TInt mimeIndex = flags.GetBitField(KMPEG2MimeMask, KMPEG2MimeShift);

 			aMatch.iMime = KMPEG2Mimes[mimeIndex];

 			}

 		}

 	}

 //

 // Attempts to parse an MPEG2 file by looking for start-codes.

 //

 void TMPEG2Parser::ParseL()

 	{

 	TBool finished;

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

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

 		{

 		iFlags.SetBit(KMPEG2VideoBit);

 		}

 	do

 		{

 		finished = NextStartCodeL();

 		}

 	while (!finished);

 	}

 //

 // Skips over the current start-code box.

 //

 void TMPEG2Parser::SkipL()

 	{

 	TUint16 size;

 	iReader.Read16L(size);

 	iReader.SeekL((TInt)size);

 	}

 /*

 ** Expects an MPEG2 Pack Header at the current location.

 ** The Pack Header is used to determine between MPEG1 and MPEG2.

 */

 void TMPEG2Parser::ReadPackHeaderL()

 	{

 	TUint8 byte;

 	TBuf8<KMPEG2PackHeaderLen> header;	// Size is of whichever is larger.

 	iReader.ReadByteL(byte);

 	if ((byte & KMPEG1PackHeaderID) == KMPEG1PackHeaderID)

 		{

 		iFlags.SetBit(KMPEG2MPEG1Bit);

 		header.SetLength(KMPEG1PackHeaderLen - 1);	// We've already read a byte.

 		iReader.ReadBytesL(header);

 		}

 	else if ((byte & KMPEG2PackHeaderID) == KMPEG2PackHeaderID)

 		{

 		header.SetLength(KMPEG2PackHeaderLen - 1);	// We've already read a byte.

 		iReader.ReadBytesL(header);

 		// The lowest 3 bits of the last byte say how much stuffing is present.

 		TInt stuffing = header[8] & 0x07; // 00000111

 		if (stuffing)

 			{

 			iReader.SeekL(stuffing);

 			}

 		}

 	else

 		{

 		User::Leave(KErrCorrupt);

 		}

 	}

 //

 // Start codes are bit patterns that do not occur in the video stream.

 // The start-code sequence is expected to be at the current CReader position.

 //

 TBool TMPEG2Parser::NextStartCodeL()

 	{

 	TUint32 data;

 	iReader.Read32L(data);

 	// Start codes must begin with 0x000001ss, where 'ss' is the start code.

 	if ((data & KStartCodeMask) != KStartCodeIntro)

 		{

 		User::Leave(KErrCorrupt);

 		}

 	if (!iFlags.GetBitField(KMPEG2StartCode1Bit))

 		{

 		iFlags.SetBit(KMPEG2StartCode1Bit);

 		}

 	else

 		{

 		if (!iFlags.GetBitField(KMPEG2StartCode2Bit))

 			{

 			iFlags.SetBit(KMPEG2StartCode2Bit);

 			}

 		}

 	// Try to identify the start code.

 	switch (LOW_BYTE(data))

 		{

 		case KPackStartCode:

 			ReadPackHeaderL();

 			break;

 		case KVideoElementaryStream:

 			iFlags.SetBit(KMPEG2VideoBit);

 			return ETrue;

 		case KISOEndCode:

 			// This code should occur at the end of the file and

 			// it cannot be skipped over.

 			return ETrue;

 		default:

 			SkipL();

 		}

 	return EFalse;

 	}