/* ==============================================================================

*  Name        : 3GPExtParser.cpp

*  Part of     : MetaDataUtility

*  Description : This class implements an 3GPExt metadata parser

*  Version     : 9

*

* Copyright (c) 2010 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.

* ==============================================================================

*/

// INCLUDE FILES

#include "3GPExtParser.h"

#include "MetaDataID3v1Genre.h"

#ifdef _DEBUG

#include	<e32svr.h>

#endif

// CONSTANTS

const TUint32 K3gpMetaMeta	= 0x6d657461;	// 'meta'

const TInt K3gpMetaLength = 1;

// ============================ MEMBER FUNCTIONS ===============================

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

// C3GPExtParser::C3GPExtParser

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

C3GPExtParser::C3GPExtParser(MP4Handle& aMP4Handle): iMP4Handle(aMP4Handle), ilst(NULL, 0)

	{

    }

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

// C3GPExtParser::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void C3GPExtParser::ConstructL()

    {

    K3GPExtMetaTitle.Format(K3GPExtMetaTitleFormat, 0xA9);

    K3GPExtMetaArtist.Format(K3GPExtMetaArtistFormat, 0xA9);

	K3GPExtMetaComposer.Format(K3GPExtMetaComposerFormat, 0xA9);

	K3GPExtMetaAlbum.Format(K3GPExtMetaAlbumFormat, 0xA9);

	K3GPExtMetaComment.Format(K3GPExtMetaCommentFormat, 0xA9);

	K3GPExtMetaCustomGenre.Format(K3GPExtMetaCustomGenreFormat, 0xA9);

	K3GPExtMetaYear.Format(K3GPExtMetaYearFormat, 0xA9);

    }

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

// C3GPExtParser::NewL

// Two-phased constructor.

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

//

EXPORT_C C3GPExtParser* C3GPExtParser::NewL(MP4Handle& aMP4Handle)

    {

#ifdef _DEBUG

	RDebug::Print(_L("C3GPExtParser::NewL"));

#endif

	C3GPExtParser* self = new( ELeave ) C3GPExtParser (aMP4Handle);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

EXPORT_C C3GPExtParser::~C3GPExtParser()

	{

	if(iChunkStatus)

		{

		iChunk.Close();

		}

	}

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

// 3GPExtParser::GetilstBoxesL

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

//

EXPORT_C void C3GPExtParser::GetilstBoxesL(const TDesC8 &/*aBox*/, TMetaDataFieldId aFieldId, HBufC** aBuf)

{

#ifdef _DEBUG

	RDebug::Print(_L("C3GPExtParser::GetilstBoxesL"));

#endif

	TUint32 offset = 0;

	TUint32 size = 0;

	switch(aFieldId)

		{

			case EMetaDataSongTitle:

				offset = iTitleOffset;

				size = iTitleSize;

				break;

			case EMetaDataArtist:

				offset = iArtistOffset;

				size = iArtistSize;

				break;

			case EMetaDataAlbum:

				offset = iAlbumOffset;

				size = iAlbumSize;

				break;

			case EMetaDataComposer:

				offset = iComposerOffset;

				size = iComposerSize;

				break;

			case EMetaDataComment:

				offset = iCommentOffset;

				size = iCommentSize;

				break;

			case EMetaDataRating:

				offset = iCustomGenreOffset;

				size = iCustomGenreSize;

				break;

			case EMetaDataYear:

				offset = iYearOffset;

				size = iYearSize;

				break;

			case EMetaDataGenre:

				offset = iGenreOffset;

				size = iGenreSize;

				break;

			case EMetaDataAlbumTrack:

				offset = iTrackNumberOffset;

				size = iTrackNumberSize;

				break;

			case EMetaDataJpeg:

				offset = iCoverOffset;

				size = iCoverSize;

				break;

			default:

				break;

		}

	if(size <= 0 || size >= (KMaxTInt/2))

		{

		User::Leave(KErrNotFound); // no data

		}

	TInt length = ilst.Length();

	if (length < 0 || length < (offset + size))

	    {

		User::Leave(KErrNotFound); // no data

	    }

	// actual data ptr

	TPtrC8 data = ilst.Mid(offset, size);

	if(aFieldId != EMetaDataGenre && aFieldId != EMetaDataAlbumTrack && aFieldId != EMetaDataJpeg)

		{ // string meta data

		*aBuf = HBufC::NewL(size);

		TPtr data16Ptr( (*aBuf)->Des() );

		data16Ptr.Copy(data);

		}

	else if(aFieldId == EMetaDataGenre)

		{ // 0x XXXX ID3v1 Genre + 1

		TInt16 num = 0;

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

			{	

			num <<= 8;

			num |= data[i];

			}

		num -= 1; // getting it to ID3

		if((num >= 0 && num <= 125) || num == 199)

			{

			*aBuf = HBufC::NewL(KMaxGenreSize);

			TPtr genrePtr = (*aBuf)->Des();

			MapID3GenreToString(num, genrePtr);

			}

		}

	else if(aFieldId == EMetaDataAlbumTrack)

		{

		*aBuf = HBufC::NewL(6);

		TUint num = 0;

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

			{	

			num <<= 8;

			num |= data[i+2];

			}

		TBuf<6> data16;

		data16.NumUC(num);

		(**aBuf) = data16;

		}

	else if(aFieldId == EMetaDataJpeg)

		{

		TPtrC8 imageMime1 = data.Mid(6, 4);

		TPtrC8 imageMime2 = data.Mid(1, 3);

		_LIT8(KJFIF, "JFIF");

		_LIT8(KPNG, "PNG");

		if(imageMime1.Compare(KJFIF) != 0 && imageMime2.Compare(KPNG) != 0)

			{

			// only JPEG and PNG supported

			User::Leave(KErrNotFound); // no data

			}

		if(imageMime1.Compare(KJFIF) == 0)

			{

			TPtrC8 pic = data.Mid(0, size);

			TInt length = pic.Length();

			if ( length )

				{

				*aBuf = HBufC::NewL( length );

				TPtr unicode( (*aBuf)->Des() );

				unicode.Copy( pic );

				}

			}

		else if(imageMime2.Compare(KPNG) == 0)

			{

			TPtrC8 pic = data.Mid(0, size);

			TInt length = pic.Length();

			if ( length )

				{

				*aBuf = HBufC::NewL( length );

				TPtr unicode( (*aBuf)->Des() );

				unicode.Copy( pic );

				}	

			}

		}

}

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

// 3GPExtParser::GetilstBoxesL for 8-bit descriptor fields 

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

//

EXPORT_C void C3GPExtParser::GetilstBoxesL(const TDesC8 &/*aBox*/, TMetaDataFieldId aFieldId, HBufC8** aBuf)

{

#ifdef _DEBUG

	RDebug::Print(_L("C3GPExtParser::GetilstBoxesL 8 bit version"));

#endif

	TUint32 offset = 0;

	TUint32 size = 0;

	switch(aFieldId)

		{

			case EMetaDataSongTitle:

				offset = iTitleOffset;

				size = iTitleSize;

				break;

			case EMetaDataArtist:

				offset = iArtistOffset;

				size = iArtistSize;

				break;

			case EMetaDataAlbum:

				offset = iAlbumOffset;

				size = iAlbumSize;

				break;

			case EMetaDataComposer:

				offset = iComposerOffset;

				size = iComposerSize;

				break;

			case EMetaDataComment:

				offset = iCommentOffset;

				size = iCommentSize;

				break;

			case EMetaDataRating:

				offset = iCustomGenreOffset;

				size = iCustomGenreSize;

				break;

			case EMetaDataYear:

				offset = iYearOffset;

				size = iYearSize;

				break;

			case EMetaDataGenre:

				offset = iGenreOffset;

				size = iGenreSize;

				break;

			case EMetaDataAlbumTrack:

				offset = iTrackNumberOffset;

				size = iTrackNumberSize;

				break;

			case EMetaDataJpeg:

				offset = iCoverOffset;

				size = iCoverSize;

				break;

			default:

				break;

		}

	if(size <= 0 || size >= (KMaxTInt/2))

		{

		User::Leave(KErrNotFound); // no data

		}

	TInt length = ilst.Length();

	if (length < 0 || length < (offset + size))

	    {

		User::Leave(KErrNotFound); // no data

	    }

	// actual data ptr

	TPtrC8 data = ilst.Mid(offset, size);

	if(aFieldId != EMetaDataGenre && aFieldId != EMetaDataAlbumTrack && aFieldId != EMetaDataJpeg)

		{ // string meta data

		*aBuf = HBufC8::NewL(size);

		TPtr8 unicode( (*aBuf)->Des() );

		unicode.Copy(data);

		}

	if(aFieldId == EMetaDataJpeg)

		{

		TPtrC8 imageMime1 = data.Mid(6, 4);

		TPtrC8 imageMime2 = data.Mid(1, 3);

		_LIT8(KJFIF, "JFIF");

		_LIT8(KPNG, "PNG");

		if(imageMime1.Compare(KJFIF) != 0 && imageMime2.Compare(KPNG) != 0)

			{

			// only JPEG and PNG supported

			User::Leave(KErrNotFound); // no data

			}

		if(imageMime1.Compare(KJFIF) == 0)

			{

			TPtrC8 pic = data.Mid(0, size);

			TInt length = pic.Length();

			if ( length )

				{

				*aBuf = HBufC8::NewL( length );

				TPtr8 unicode( (*aBuf)->Des() );

				unicode.Copy( pic );

				}

			}

		else if(imageMime2.Compare(KPNG) == 0)

			{

			TPtrC8 pic = data.Mid(0, size);

			TInt length = pic.Length();

			if ( length )

				{

				*aBuf = HBufC8::NewL( length );

				TPtr8 unicode( (*aBuf)->Des() );

				unicode.Copy( pic );

				}	

			}

		}

}

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

// C3GPExtParser::Is3GPExtMetadataL

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

//

EXPORT_C TBool C3GPExtParser::Is3GPExtMetadataL()

	{

#ifdef _DEBUG

	RDebug::Print(_L("C3GPExtParser::3GPExtMetadataL"));

#endif

	HBufC8* frame = HBufC8::NewLC( K3gpMetaLength );

	TUint8* buffer = CONST_CAST(TUint8*, frame->Ptr());

	MP4Err err;

	mp4_u8 udtaLocation = MP4_UDTA_MOOV;

	mp4_u32 bufferSize = K3gpMetaLength;

	mp4_u32 atomIndex = 0;

	err = MP4ParseGetUserDataAtom(iMP4Handle, udtaLocation, K3gpMetaMeta, buffer,

			bufferSize, atomIndex);

	if (bufferSize > (KMaxTInt / 2))

	    {

		User::Leave(KErrNotFound); // no data	    

	    }

	if ( err == MP4_UDTA_NOT_FOUND )

		{

		if ( udtaLocation == MP4_UDTA_NONE || udtaLocation == MP4_UDTA_MOOV )

			{

#ifdef _DEBUG

	RDebug::Print(_L("3GPExtParser::Parse3GPExtL - NotFound"));

#endif

			CleanupStack::PopAndDestroy();  // frame

			return EFalse;

			}

		else

			{

			if ( udtaLocation & MP4_UDTA_AUDIOTRAK )

				{

				udtaLocation = MP4_UDTA_AUDIOTRAK;

				}

			else 	// MP4_UDTA_VIDEOTRAK

				{

				udtaLocation = MP4_UDTA_VIDEOTRAK;

				}

			}

#ifdef _DEBUG

	RDebug::Print(_L("3GPExtParser::Parse3GPExtL - New Location [%d]"), udtaLocation);

#endif

		err = MP4ParseGetUserDataAtom(iMP4Handle, udtaLocation, K3gpMetaMeta, buffer,

			bufferSize, atomIndex);

		}

	if ( err != MP4_OK )

		{

		if ( err == MP4_OUTPUT_BUFFER_TOO_SMALL )

			{

			iChunk.Close();

			User::LeaveIfError(iChunk.CreateLocal(bufferSize, bufferSize, EOwnerProcess));

			iChunkStatus = ETrue;

			buffer = iChunk.Base();

			err = MP4ParseGetUserDataAtom(iMP4Handle, udtaLocation, K3gpMetaMeta, buffer, bufferSize, atomIndex);

			if(err != MP4_OK)

				{

				CleanupStack::PopAndDestroy();  // frame

				return EFalse;

				}

			}

		else

			{

			CleanupStack::PopAndDestroy();  // frame

			return EFalse;

			//User::Leave( TranslateMP4Err(err) );

			}

		}

	TPtr8 des(buffer, bufferSize, bufferSize);

	// HDLR BOX

	_LIT8(KHdlr, "hdlr");

	TInt hdlrOffset = 16; // header box at constant offset

	TPtrC8 hdlrCheck = des.MidTPtr(hdlrOffset, 4);

	if(hdlrCheck !=  KHdlr)

	{ 

		CleanupStack::PopAndDestroy();  // frame

		return EFalse; // not 3GPExt

	}

	hdlrOffset -= 4; // hdlr box begins at size, 4 bytes back

	// get hdlr size

	TPtrC8 sizeHdlrDesc = des.Mid(hdlrOffset, 4);

	TInt32 sizeHdlr = 0;

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

		{	

		sizeHdlr <<= 8;

		sizeHdlr |= sizeHdlrDesc[i];

		}

	if(sizeHdlr <= 0)

	    {

		CleanupStack::PopAndDestroy();  // frame

		return EFalse; // not 3GPExt

	    }

	// hdlr ptr

	if (des.Length() < (hdlrOffset + sizeHdlr))

	    {

	    CleanupStack::PopAndDestroy();  // frame

	    return EFalse;  // data corrupted

	    }	        

	TPtrC8 hdlr = des.Mid(hdlrOffset, sizeHdlr);

	// match mdirappl

	/**** Comment out the following lines - no need to test for "mdirappl" string	

	TPtrC8 text = hdlr.Mid(16, 8); // at 16 bytes from hdlr box

	_LIT8(KMdirappl, "mdirappl");

	if(text.Compare(KMdirappl) != 0)

	{

		CleanupStack::PopAndDestroy();  	// frame

		return EFalse; 						// not 3GPExt

	}

	*****/   // End comment out "mdirappl" 	

	// iLST BOX

	_LIT8(KIlst, "ilst");

	TInt ilstOffset = hdlrOffset + sizeHdlr + 4;

	if (ilstOffset > bufferSize)

	    {

		CleanupStack::PopAndDestroy();  // frame

		return EFalse; // not 3GPExt	    

	    }

	TPtrC8 ilstCheck = des.MidTPtr(ilstOffset, 4);

	if(ilstCheck !=  KIlst)

	    {

	    ilstOffset = des.Find(KIlst);

	    if(ilstOffset == KErrNotFound)

	        {

	        CleanupStack::PopAndDestroy();  // frame

	        return EFalse; // no list box

	        }

	    }

	ilstOffset -=4; // ilst box begins at size, 4 bytes back

	// get ilst size

	TPtrC8 sizeIlstDesc = des.Mid(ilstOffset, 4);

	TUint32 sizeIlst = 0;

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

		{	

		sizeIlst <<= 8;

		sizeIlst |= sizeIlstDesc[i];

		}

	if(sizeIlst <= 0 || sizeIlst > bufferSize - ilstOffset)

	{

		CleanupStack::PopAndDestroy();  // frame

		return EFalse; // no list box

	}

	// ilst 

	TPtrC8 tmp = des.Mid(ilstOffset, sizeIlst);

	const TUint8* tmpPtr = tmp.Ptr();

	ilst.Set(tmpPtr, sizeIlst);

	iExists = ETrue;

	ParseIlstBoxesL();

	CleanupStack::PopAndDestroy();  // frame	

	return ETrue;

	}

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

// 3GPExtParser::MapID3v1GenreToString()

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

//

void C3GPExtParser::ParseIlstBoxesL()

{

#ifdef _DEBUG

	RDebug::Print(_L("C3GPExtParser::ParseIlstBoxesL"));

#endif

	TUint32 sizeIlst = ilst.Length();

	TUint32 offset = 8; // first tag

	while (offset < sizeIlst)	

		{

		TUint32 tagSize = 0;

		TPtrC8 tagSizeDes = ilst.Mid(offset, 4);

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

			{	

			tagSize <<= 8;

			tagSize |= tagSizeDes[i];

			}