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

//
// Brands.
// Some (most) brands have Release information - e.g. 3gp6, 3gp5 etc.
// Therefore, to match the brand, we only look at the characters that don't
// represent Release information (in the above case, the 4th character).
// The Release character is set to zero.
//
static const TUint32 KMP4Brand = MAKE_INT32('m', 'p', '4', 0);
static const TUint32 K3GPBrand = MAKE_INT32('3', 'g', 'p', 0);
static const TUint32 K3G2Brand = MAKE_INT32('3', 'g', '2', 0);
static const TUint32 K3GSBrand = MAKE_INT32('3', 'g', 's', 0);	// Streaming servers.
static const TUint32 K3GRBrand = MAKE_INT32('3', 'g', 'r', 0);	// Progresive download and MMS.
static const TUint32 KQTBrand  = MAKE_INT32('q', 't', ' ', ' '); // for quicktime
//
// Box identifiers.
//
static const TUint32 KFtyp = MAKE_INT32('f', 't', 'y', 'p');
static const TUint32 KMoov = MAKE_INT32('m', 'o', 'o', 'v');
static const TUint32 KTrak = MAKE_INT32('t', 'r', 'a', 'k');
static const TUint32 KTkhd = MAKE_INT32('t', 'k', 'h', 'd');
static const TUint32 KMdia = MAKE_INT32('m', 'd', 'i', 'a');
static const TUint32 KHdlr = MAKE_INT32('h', 'd', 'l', 'r');
static const TUint32 KVide = MAKE_INT32('v', 'i', 'd', 'e');
static const TUint32 KUuid = MAKE_INT32('u', 'u', 'i', 'd');


//
// This truth table maps the following flags to a confidence level.
//
// A - trak box present
// B - moov box present
//
// A B -> Confidence
// =================
// 0 0 -> EPossible
// 0 1 -> EProbable
// 1 0 -> EProbable
// 1 1 -> ECertain
//
static const TInt KMPEG4FlagsToConfidence[] =
	{
	KConfPossible,
	KConfProbable,
	KConfProbable,
	KConfCertain,
	};


#define KMPEG4ConfidenceMask	0x03	// 00000011
#define KMPEG4BoxTitleLen		4
#define KMPEG4TRAKBit			KBit0	// 00000001
#define KMPEG4MOOVBit			KBit1	// 00000010
#define KMPEG4VideoBit			KBit2	// 00000100

static const TInt KMPEG4BoxIntroLen = 8;
static const TInt KMPEG4Box64BitIntroLen = 16;

//
// In order to find out the type of MPEG4 file it is
// we need to be able to map known extensions, expected
// ftyp expressions with MIME-types.
//
typedef struct
	{
	const TText* iExt;
	TUint32 iBrand;
	const TText8* iAudioMime;
	const TText8* iVideoMime;
	}
TMPEG4File;


//
// A table of ftyp's, extensions and mime-types.
//
// .mp4 - can contain either audio or video.
// .m4a - should contain (unprotected) audio only.
// .m4p - should contain protected audio only.
// .3gp - can contain either audio or video.
//
static const TMPEG4File KMPEG4Files[] =
	{
		{KExtMP4,	KMP4Brand,	KMimeMP4_A,	KMimeMP4_V},
		{KExt3GP,	K3GPBrand,	KMime3GP_A,	KMime3GP_V},
		{KExtM4A,	KMP4Brand,	KMimeMP4_A,	NULL},
		{KExt3G2,	K3G2Brand,	KMime3G2_A,	KMime3G2_V},
		{KExt3GP,	K3GSBrand,	KMime3GP_A,	KMime3GP_V},
		{KExt3GP,	K3GRBrand,	KMime3GP_A,	KMime3GP_V},
		{KExt3GA,	K3GPBrand,	KMime3GA,	NULL},
		{KExtMOV,   KQTBrand,   NULL, KMimeQuickV} // this entry is for .mov files
	};

static const TInt KMPEG4FileTypeCount = sizeof(KMPEG4Files) / sizeof(TMPEG4File);


//
//
//
TMPEG4Parser::TMPEG4Parser(CReader& aReader, TFlags& aFlags)
 :	iBrandIndex(KErrNotFound),
 	iIsFinished(EFalse),
 	iReader(aReader),
 	iFlags(aFlags),
 	iVideoAssumed(EFalse)
	{
	}


//
// Compare a brand with the ones this recogniser knows about.
//
TInt TMPEG4Parser::IsCompatibleBrand(TUint32 aBrand, TInt aStartPos)
	{
	for (TInt i = aStartPos; i < KMPEG4FileTypeCount; i++)
		{
		TUint32 knownBrand = KMPEG4Files[i].iBrand;
		if ((aBrand & knownBrand) == knownBrand)
			{
			return i;
			}
		}

	return KErrNotFound;
	}


//
// Try to determine the mime-type from the extension, and
// if that isn't matched, from the FTYP field if present.
// If none of these are matched, NULL is returned and the
// file isn't a valid MPEG4 file.
//
const TText8* TMPEG4Parser::MatchFileType(const TDesC& aExt)
	{
	TBool videoFound = iFlags.GetBitField(KMPEG4VideoBit);
	TBool video = (videoFound || iVideoAssumed);
	
	// Try to match the extension.
	if (aExt.Length() > 0)
		{
		for (TInt i = 0; i < KMPEG4FileTypeCount; i++)
			{
			TPtrC ext(KMPEG4Files[i].iExt);
			if (aExt.MatchF(ext) != KErrNotFound)
				{
				// Extension match. If the extension is for an audio-only format
				// we must make sure there is no video content in the file. If
				// video content is present then ignore the extension match.
				if (KMPEG4Files[i].iVideoMime == NULL)
					{
					if (videoFound)
						{
						// Try to match another extension.
						continue;
						}
					
					return KMPEG4Files[i].iAudioMime;
					}
				
				return (video ? KMPEG4Files[i].iVideoMime : KMPEG4Files[i].iAudioMime);
				}
			}
		}

	// Unknown or no extension. Try to match the brand
	while (iBrandIndex != KErrNotFound)
		{
		if (KMPEG4Files[iBrandIndex].iVideoMime == NULL)
			{
			if (videoFound)
				{
				// Try to match another brand.
				TUint32 brand = KMPEG4Files[iBrandIndex].iBrand;
				iBrandIndex = TMPEG4Parser::IsCompatibleBrand(brand, iBrandIndex + 1);
				continue;
				}
			
			return KMPEG4Files[iBrandIndex].iAudioMime;
			}
		
		return (video ? KMPEG4Files[iBrandIndex].iVideoMime : KMPEG4Files[iBrandIndex].iAudioMime);
		}

	// If there is no brand and an unknown extension look at the flags.
	// (There are some files that have no ftyp).
	// Only return a potential mime-type if all flag bits have been set.
	if (iFlags.GetBitField(KMPEG4ConfidenceMask) == KMPEG4ConfidenceMask)
		{
		return (video ? KMimeMP4_V : KMimeMP4_A);
		}
		
	return NULL;
	}


//
//
//
void TMPEG4Parser::DoRecognise(const TDesC& aFileExt, CReader& aReader, TMatch& aMatch)
	{
	TFlags flags;
	TMPEG4Parser parser(aReader, flags);
			
	TRAP_IGNORE(parser.ParseL());
	
	// The extension determines the mime-type.
	// The flags say if it's a valid MPEG4 file and if video is present.
	const TText8* extMime = parser.MatchFileType(aFileExt);
	if (extMime != NULL)
		{
		TInt confIndex = flags.GetBitField(KMPEG4ConfidenceMask);
		aMatch.iConfidence = KMPEG4FlagsToConfidence[confIndex];
		if (aMatch.iConfidence != KConfNotRecognised)
			{
			aMatch.iMime = extMime;
			}
		}
	}
	

//
//
//
void TMPEG4Parser::ParseL()
	{
	// If we have only buffer data, we must assume the video
	// content (if any) has been missed. This is because an
	// audio-only file recognised as video should play in a
	// video application, but a video file recognised as audio
	// will not play in a audio application.
	if (iReader.Type() == CReader::EBuffer)
		{
		iVideoAssumed = ETrue;
		}
		
	do
		{		
		ReadBoxHeaderL();
		if (iTitle == KFtyp)
			{
			ReadFileTypeL();
			}
		else if (iTitle == KMoov)
			{
			iFlags.SetBit(KMPEG4MOOVBit);
			ReadMovieL();
			}
		else
			{
			SkipCurrentBoxL();
			}
		}
	while (!iIsFinished);
	}


//
//
//
void TMPEG4Parser::SkipCurrentBoxL()
	{
	// Intro: [size][title] = 8 bytes.
		
	if (iSize == 0)
		{
		// The current box extends to the end of file.
		iIsFinished = ETrue;
		return;
		}
	if(iSizeIn32bit)
	    {
        iReader.SeekL(iSize - KMPEG4BoxIntroLen);
	    }
	else
	    {
        iReader.SeekL(iSize - KMPEG4Box64BitIntroLen);
	    }
	}


//
// Parses the 'moov' box.
// This box contains sub-boxes we're interested in.
//
void TMPEG4Parser::ReadMovieL()
	{
	// This box holds no information.
	// It contains 'trak' boxes, which we want.
	
	TInt64 dataInBox = iSize - KMPEG4BoxIntroLen;
	
	while ((dataInBox > 0) && !iIsFinished)
		{
		ReadBoxHeaderL();
		dataInBox -= iSize;
		
		if (iTitle == KTrak)
			{
			iFlags.SetBit(KMPEG4TRAKBit);
			ReadTrackL();
			}
		else
			{
			SkipCurrentBoxL();
			}
		}
	}
	

//
// Parses the 'trak' box.
// This box contains sub-boxes we're interested in.
//
void TMPEG4Parser::ReadTrackL()
	{
	// This box holds no information.
	// It contains 'tkhd' boxes, which we want.
	
	TInt64 dataInBox = iSize - KMPEG4BoxIntroLen;
	
	while ((dataInBox > 0) && !iIsFinished) 
		{
		ReadBoxHeaderL();
		dataInBox -= iSize;
		
		if (iTitle == KTkhd)
			{
			ReadTrackHeaderL();
			}
		else if (iTitle == KMdia)
			{
			ReadMediaL();
			}
		else
			{
			SkipCurrentBoxL();
			}
		}
	}

//
// Parses a 'mdia' box.
// This box contains sub-boxes we're interested in.
//
void TMPEG4Parser::ReadMediaL()
	{
	TInt64 dataInBox = iSize - KMPEG4BoxIntroLen;
	
	while ((dataInBox > 0) && !iIsFinished)
		{
		ReadBoxHeaderL();
		dataInBox -= iSize;
		
		if (iTitle == KHdlr)
			{
			ReadHandlerL();
			}
		else
			{
			SkipCurrentBoxL();
			}
		}
	}


//
// Parses a 'hdlr' box.
// This is a stand-alone box.
//
void TMPEG4Parser::ReadHandlerL()
	{
	// Intro: [size][title][versionFlags][predefined][handler_type] = 20 bytes.
	const TInt KMPEG4HandlerIntroLen = 20;
	TUint32 versionFlags;
	TUint32 predefined;
	TUint32 handler;

	iReader.Read32L(versionFlags);
	iReader.Read32L(predefined);
	if (predefined != 0)
		{
		User::Leave(KErrCorrupt);
		}
		
	iReader.Read32L(handler);
	if (handler == KVide)
		{
		iFlags.SetBit(KMPEG4VideoBit);
		}
		
	iReader.SeekL(iSize - KMPEG4HandlerIntroLen);
	}


//
//
//
void TMPEG4Parser::ReadTrackHeaderL()
	{
	const TUint8 KMPEG4TrackVersion0 = 0;
	const TUint8 KMPEG4TrackVersion1 = 1;
	const TInt KMPEG4Version0ToVolume = 32; // Distance to volume field from version=0 field.
	const TInt KMPEG4Version1ToVolume = 44; // Distance to volume field from version=1 field.
	const TInt KMPEG4VolumeToWidth = 38;	// Distance to width field from volume field.

	TUint32 versionFlags;
	TUint16 volume;
	TUint32 width;
	TUint32 height;
	
	// This box contains information about a single track.
	iReader.Read32L(versionFlags);
	
	// The highest 8 bits contains the version.
	switch (HIGH_BYTE32(versionFlags))
		{
		case KMPEG4TrackVersion0:
			iReader.SeekL(KMPEG4Version0ToVolume);
			break;
			
		case KMPEG4TrackVersion1:
			iReader.SeekL(KMPEG4Version1ToVolume);
			break;
			
		default:
			User::Leave(KErrCorrupt);
		}
	
	// Volume can not be used to distinguish between audio and video anymore.
	iReader.Read16L(volume);
		
	// We want to seek ahead to read the 'width' and 'height' fields.
	iReader.SeekL(KMPEG4VolumeToWidth);

	iReader.Read32L(width);		// 16.16 fixed-point
	iReader.Read32L(height);	// 16.16 fixed-point
	if ((width != 0) && (height != 0))
		{
		iFlags.SetBit(KMPEG4VideoBit);
		}
	}

	
//
// Parses the 'ftyp' box.
// Records the first recognised brand that helps to
// identify the mime-type.
//
void TMPEG4Parser::ReadFileTypeL()
	{
	// Intro = [size][title][majorBrand] = 12 bytes.
	const TInt KMPEG4FtypIntroLen = 12;
	TUint32 brand;
	
	// If the majorBrand isn't recognised we should also
	// search the compatible brand list.
	TInt64 bytesRemaining = iSize - KMPEG4FtypIntroLen;
	//here there should be bytes remaining. Otherwise we cant read.
	if( bytesRemaining <0 )
	{
	    User::Leave(KErrCorrupt);    
	}
	
	iReader.Read32L(brand);
	iBrandIndex = TMPEG4Parser::IsCompatibleBrand(brand);
	if (iBrandIndex != KErrNotFound)
		{
		// The major brand was recognised.
		// Skip to the end of the ftyp box.
		iReader.SeekL(bytesRemaining);
		return;
		}
		
	// The major brand wasn't recognised.
	// Skip over the version info (32 bit) to the start of the
	// compatible brands list.
	TInt skip = sizeof(TUint32);
	iReader.SeekL(skip);
	bytesRemaining -= skip;
	
	while ((iBrandIndex == KErrNotFound) && (bytesRemaining > 0))
		{
		iReader.Read32L(brand);
		bytesRemaining -= skip;
		iBrandIndex = TMPEG4Parser::IsCompatibleBrand(brand);
		}

	iReader.SeekL(bytesRemaining);
	}


//
// Reads the first few bytes of a box.
// The exact amount read depends on the box.
//
void TMPEG4Parser::ReadBoxHeaderL()
	{
	const TInt KMPEG4ExtendedTypeLen = 16;
	
	TUint32 word1;

	iReader.Read32L(word1);
	iReader.Read32L(iTitle);

	switch (word1)
		{
		case 0:
			// Box extends to the end of file.
			iSize = MAKE_TINT64(0, 0);
			break;
			
		case 1:
			// Size is specified in a 64-bit field.
		    iSizeIn32bit = EFalse;
			iReader.Read64L(iSize);
			break;
			
		default:
			// It's an actual 32-bit size.
		    iSizeIn32bit = ETrue;
			iSize = MAKE_TINT64(0, word1);
		}
		
	if (iTitle == KUuid)
		{
		// Skip the extended type.
		iReader.SeekL(KMPEG4ExtendedTypeLen);
		}
	}