/*

* Copyright (c) 2004 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:  This class implements an ID3v1 and v1.1 parser as specified in

*                www.id3.org.

*

*/

// INCLUDE FILES

#include	"MetaDataParserWMA.h"

#ifdef _DEBUG

#include	<e32svr.h>

#endif

#include <s32mem.h>

// CONSTANTS

// ASF Header Object GUIDs 

_LIT8 (KASFContentDescriptionObject, "75B22633668E11CFA6D900AA0062CE6C");

_LIT8 (KASFExtendedContentDescriptionObject, "D2D0A440E30711D297F000A0C95EA850");

_LIT8 (KASFHeaderObject, "75B22630668E11CFA6D900AA0062CE6C");

_LIT8 (KASFFilePropertiesObject, "8CABDCA1A94711CF8EE400C00C205365");

_LIT8 (KASFHeaderExtensionObject, "5FBF03B5A92E11CF8EE300C00C205365");

_LIT8 (KASFMetadataLibraryObject, "44231C94949849D1A1411D134E457054");

_LIT(KWMAlbumTitle, "WM/AlbumTitle\0");

_LIT(KWMPicture,	"WM/Picture\0");

_LIT(KWMText,		"WM/Text\0");

_LIT(KWMComposer,	"WM/Composer\0");

_LIT(KWMGenre,		"WM/Genre\0");

_LIT(KWMYear,		"WM/Year\0");

_LIT(KWMYear1,		"WM/OriginalReleaseYear\0"); 

_LIT(KWMOriginalArtist,	"WM/OriginalArtist\0");

_LIT(KWMTrackNumber,	"WM/TrackNumber\0");

_LIT(KWMUniqueFileIdentifier,	"WM/UniqueFileIdentifier\0");

_LIT(KWMAudioFileURL,	"WM/AudioFileURL\0");

_LIT(KWMSharedUserRating, "WM/SharedUserRating\0");

_LIT(KWMDate, "WM/OriginalReleaseTime\0");

#ifdef __WINDOWS_MEDIA

_LIT(KWMProvider, "WM/Provider\0");

#endif

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

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

// CMetaDataParserWMA::CMetaDataParserWMA

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

// might leave.

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

//

CMetaDataParserWMA::CMetaDataParserWMA(

	CMetaDataSource& aSource )

	:	iSource(aSource),

		iCharacterSetId(0)

	{

    }

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

// CMetaDataParserWMA::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMetaDataParserWMA::ConstructL()

    {

	if ( ValidateL() )

		{

		User::LeaveIfError(iFs.Connect());

		// Get list of charconv supported character sets

		iCharacterSet = CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableL(iFs);

		}

#ifdef _DEBUG

	RDebug::Print(_L("CMetaDataParserWMA::ConstructL - Done"));

#endif

    }

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

// CMetaDataParserWMA::NewL

// Two-phased constructor.

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

//

CMetaDataParserWMA* CMetaDataParserWMA::NewL(

	CMetaDataSource& aSource )

    {

#ifdef _DEBUG

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

#endif

	CMetaDataParserWMA* self = new( ELeave ) CMetaDataParserWMA(aSource);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CMetaDataParserWMA::~CMetaDataParserWMA()

	{

		delete iHeaderData;

		delete iCharacterSet;

		iFs.Close();

	}

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

// CMetaDataParserWMA::ParseL

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

//

void CMetaDataParserWMA::ParseL(

	const RArray<TMetaDataFieldId>& aWantedFields,

	CMetaDataFieldContainer& aContainer )

    {

#ifdef _DEBUG

	RDebug::Print(_L("CMetaDataParserWMA::ParseL"));

#endif

	iContainer = &aContainer;

	if(iContentDescriptionObjectExists)

		{

		ParseContentDescriptionObject();

		}

	if(iExtendedContentDescriptionObjectExists)

		{

		ParseExtendedContentDescriptionObjectL();

		}

	if(iHeaderExtensionObjectExists)

		{

		ParseHeaderExtensionObjectL();

		if(iMetadataLibraryObjectExists)

			{

			ParseMetadataLibraryObjectL();

			}

		}	

	TInt err = KErrNone; // ignore err, as some entry may be extracted without exception

	if ( aWantedFields.Count() == 0 )

		{

		TRAP(err, GetTitleL());

		TRAP(err, GetAuthorL());

		TRAP(err, GetCopyrightL());

		TRAP(err, GetCommentL());

		TRAP(err, GetJpegL());

		TRAP(err, GetExtContDesEntryL(EMetaDataRating, iSharedUserRatingOffset));

		TRAP(err, GetExtContDesEntryL(EMetaDataAlbum, iAlbumTitleOffset));

		TRAP(err, GetExtContDesEntryL(EMetaDataComment, iTextOffset));

		TRAP(err, GetExtContDesEntryL(EMetaDataComposer, iComposerOffset));

		TRAP(err, GetExtContDesEntryL(EMetaDataGenre, iGenreOffset));

		TRAP(err, GetExtContDesEntryL(EMetaDataYear, iYearOffset));

		TRAP(err, GetExtContDesEntryL(EMetaDataOriginalArtist, iOriginalArtistOffset));

		TRAP(err, GetExtContDesEntryL(EMetaDataAlbumTrack, iTrackNumberOffset));

		TRAP(err, GetExtContDesEntryL(EMetaDataUniqueFileIdentifier, iUniqueFileIdentifierOffset));

		TRAP(err, GetExtContDesEntryL(EMetaDataUrl, iAudioFileURLOffset));

		TRAP(err, GetDurationL());

		TRAP(err, GetExtContDesEntryL(EMetaDataDate, iDateOffset));

	#ifdef __WINDOWS_MEDIA

		TRAP(err, GetExtContDesEntryL(EMetaDataVendor, iProviderOffset));

	#endif

		}

	else

		{

		// Look for it in the wanted field array

		TInt count( aWantedFields.Count() );

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

			{

			switch ( aWantedFields[ i ] )

				{

				case EMetaDataSongTitle:

					TRAP(err, GetTitleL());

					break;

				case EMetaDataArtist:

					TRAP(err, GetAuthorL());

					break;

				case EMetaDataCopyright:

					TRAP(err, GetCopyrightL());

					break;

				case EMetaDataRating:

					TRAP(err, GetExtContDesEntryL(EMetaDataRating, iSharedUserRatingOffset));

					break;

				case EMetaDataJpeg:

					TRAP(err, GetJpegL());

					break;

				case EMetaDataAlbum:

					TRAP(err, GetExtContDesEntryL(EMetaDataAlbum, iAlbumTitleOffset));

					break;

				case EMetaDataComment:

					TRAP(err, GetExtContDesEntryL(EMetaDataComment, iTextOffset));

					break;

				case EMetaDataComposer:

					TRAP(err, GetExtContDesEntryL(EMetaDataComposer, iComposerOffset));

					break;

				case EMetaDataGenre:

					TRAP(err, GetExtContDesEntryL(EMetaDataGenre, iGenreOffset));

					break;

				case EMetaDataYear:

					TRAP(err, GetExtContDesEntryL(EMetaDataYear, iYearOffset));

					break;

				case EMetaDataOriginalArtist:

					TRAP(err, GetExtContDesEntryL(EMetaDataOriginalArtist, iOriginalArtistOffset));

					break;

				case EMetaDataAlbumTrack:

					TRAP(err, GetExtContDesEntryL(EMetaDataAlbumTrack, iTrackNumberOffset));

					break;

				case EMetaDataUniqueFileIdentifier:

					TRAP(err, GetExtContDesEntryL(EMetaDataUniqueFileIdentifier, iUniqueFileIdentifierOffset));

					break;

				case EMetaDataUrl:

					TRAP(err, GetExtContDesEntryL(EMetaDataUrl, iAudioFileURLOffset));

					break;

				case EMetaDataDuration:

					TRAP(err, GetDurationL());

					break;

				case EMetaDataDate:

					TRAP(err, GetExtContDesEntryL(EMetaDataDate, iDateOffset));

					break;

			#ifdef __WINDOWS_MEDIA

				case EMetaDataVendor:

					TRAP(err, GetExtContDesEntryL(EMetaDataVendor, iProviderOffset));

			#endif

				default:

					break;

				}

			}

		}

    }

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

// CMetaDataParserWMA::ValidateL

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

//

TBool CMetaDataParserWMA::ValidateL()

	{

	TInt size;

	iExists = EFalse;

	User::LeaveIfError( iSource.Size( size ) );

	if ( size <= 0 )

		{

		return EFalse;

		}

	// ASF_Header_Object GUID 128 bits.

	TBuf8<32> header; 

	iSource.ReadL(header, 16);

	if(header.Length() < 16)

		{

		return EFalse;

		}

	FormatGUID(header);

	if(header !=  KASFHeaderObject)

		{

		return EFalse;

		}

	// read header object size.

	iSource.ReadL(header, 8);

	TInt headerSize = ConvertToInt64(header);

	if(headerSize <= 30)

		{

		return EFalse; // header object is empty.

		}

	if(headerSize >= size) //Header Size is too high

		{

		return EFalse; // header size is more than the file size.

		}

	// read header object

	// 2~31 = 2 GB, size of header would not be greater than this,

	// also, HBufC does not have a NewL with TInt64 as arguement.

	iHeaderData = HBufC8::NewL(headerSize); 

	TPtr8 headerPtr = iHeaderData->Des(); 

	iSource.ReadL(headerPtr, headerSize - 24);

	TBuf8<4> objects = iHeaderData->Mid(0, 4);

	TInt noOfObjects = ConvertToInt32(objects);

	if(noOfObjects <= 0)

		{

		iExists = EFalse;

		return EFalse; // no objects. 

		}

	TInt objOffset = 6;

	if(objOffset+16 > iHeaderData->Length()) //Header Size is too small

		{

		return EFalse;

		} 

	TBuf8<32> objGUID = iHeaderData->Mid(objOffset, 16);

	FormatGUID(objGUID);

	TBool loop = ETrue;

	TInt objectCount = 0;

	while (loop)

		{

		if(!iContentDescriptionObjectExists && objGUID == KASFContentDescriptionObject)

			{

			iContentDescriptionObjectExists = ETrue;

			iContentDescriptionOffset = objOffset;

			}

		if(!iFilePropertiesObjectExists && objGUID == KASFFilePropertiesObject)

			{

			iFilePropertiesObjectExists = ETrue; // must exist

			iFilePropertiesOffset = objOffset;

			}

		if(!iExtendedContentDescriptionObjectExists && objGUID == 

			KASFExtendedContentDescriptionObject)

			{

			iExtendedContentDescriptionObjectExists = ETrue;

			iExtendedContentDescriptionOffset = objOffset;

			}

		if(!iHeaderExtensionObjectExists && objGUID == 

			KASFHeaderExtensionObject)

			{

			iHeaderExtensionObjectExists = ETrue;

			iHeaderExtensionOffset = objOffset;

			}	

		TBuf8<8> size = iHeaderData->Mid(objOffset + 16, 8); 

		TInt objSize = ConvertToInt64(size); // upper 32 bits?

		if(0 > objSize)

			{

			return EFalse;

			}

		objOffset += objSize;

		if(objOffset >= headerSize - 30 || 

			(iContentDescriptionObjectExists && iFilePropertiesObjectExists 

			&& iExtendedContentDescriptionObjectExists && iHeaderExtensionObjectExists) )

			{

			loop = EFalse;

			}

		else

			{

			objGUID = iHeaderData->Mid(objOffset, 16);

			FormatGUID(objGUID);

			objectCount++;

			if (objectCount == noOfObjects)

				{

				iExists = EFalse;

				return EFalse;	// gone through all objects		

				}

			}

		}

	if(iFilePropertiesObjectExists) 

		{

		iExists = ETrue;

		}

	return iExists;

	}

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

// CMetaDataParserWMA::FormatGUID

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

//

void CMetaDataParserWMA::FormatGUID(TDes8 &aGUID)

{

	TBuf8<16> copyGUID(aGUID);

	TInt i;

	for(i = 0; i < 4; i++)

		{

		copyGUID[i] = aGUID[3-i];

		}

	for(i = 4; i < 6; i++)

		{

		copyGUID[i] = aGUID[9 - i];

		}

	for (i = 6; i < 8; i++)

		{

		copyGUID[i] = aGUID[13 - i];

		}

	for(i = 8; i < 16 ; i++)

		{

		copyGUID[i] = aGUID[i];

		}

	aGUID.Delete(0, 32);

	for(i = 0; i <16; i++)

		{

			aGUID.AppendNumFixedWidthUC(copyGUID[i], EHex, 2);

		}

}

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

// CMetaDataParserWMA::ConvertToInt64

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

//

TInt64 CMetaDataParserWMA::ConvertToInt64(TDesC8& aDes)

{

	TInt64 num = 0;

	TInt i;

	for(i = 7 ; i >= 0; i--)

		{

		num <<= 8;

		num |= aDes[i];

		}

	return num;

}

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

// CMetaDataParserWMA::ConvertToInt32

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

//

TInt CMetaDataParserWMA::ConvertToInt32(TDesC8& aDes)

{

	TInt num = 0;

	for(TInt i = 3 ; i >= 0; i--)

		{	

		num <<= 8;

		num |= aDes[i];

		}

	return num;

}

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

// CMetaDataParserWMA::ConvertToInt16

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

//

TInt CMetaDataParserWMA::ConvertToInt16(TDesC8& aDes)

{

	TInt num = 0;

	for(TInt i = 1 ; i >= 0; i--)

		{	

		num <<= 8;

		num |= aDes[i];

		}

	return num;

}

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

// CMetaDataParserWMA::ConvertDes8toDes16

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

//

void CMetaDataParserWMA::ConvertDes8toDes16(const TDesC8& aDes8,TDes16& aDes16)

	{

	for(TInt i = 0 ; i < aDes8.Length(); i+=2)

		{

		if(aDes16.MaxLength() <= i/2)

			{

#ifdef _DEBUG

	RDebug::Print(_L("CMetaDataParserWMA::ConvertDes8toDes16: i/2[%d] >= aDes16's MaxLength[%d]."),

			i/2, aDes16.MaxLength());

#endif

			return;

			}

		aDes16.Append(aDes8[i]);

		}

	}

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

// CMetaDataParserWMA::GetTitleL

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

//

void CMetaDataParserWMA::GetTitleL()

	{

	if (iTitleLength <= 0)

		{

		return;

		}

	TInt offset = iContentDescriptionOffset + 34;

	if(iTitleLength - 2 <= 0 || offset + iTitleLength > iHeaderData->Length())

		{

		return; // empty title or corrupt title length

		}

	TPtrC8 title = iHeaderData->Mid(offset, iTitleLength - 2);

	HBufC* data16 = HBufC::NewLC( iTitleLength - 2);

	TPtr titleUnicode( data16->Des() );

	if ( ConvertToUnicodeL(title, titleUnicode) == KErrNone )

		{

		iContainer->AppendL( EMetaDataSongTitle, titleUnicode );

		}

	CleanupStack::PopAndDestroy();  // data16

	}

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

// CMetaDataParserWMA::GetArtistL

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

//

void CMetaDataParserWMA::GetAuthorL()

	{

	if (iAuthorLength <= 0)

		{

		return;

		}

	TInt offset = iContentDescriptionOffset + 34 + iTitleLength;

	if(iAuthorLength - 2 <= 0 || offset + iAuthorLength > iHeaderData->Length())

		{

		return; // empty author or corrupt author length

		}

	TPtrC8 author = iHeaderData->Mid(offset, iAuthorLength - 2);

	HBufC* data16 = HBufC::NewLC( iAuthorLength - 2);

	TPtr authorUnicode( data16->Des() );

	if ( ConvertToUnicodeL(author, authorUnicode) == KErrNone )

		{

		iContainer->AppendL( EMetaDataArtist, authorUnicode );

		}

	CleanupStack::PopAndDestroy();  // data16

	}

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

// CMetaDataParserWMA::GetCopyrightL

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

//

void CMetaDataParserWMA::GetCopyrightL()

	{

	if (iCopyrightLength <= 0)

		{

		return;

		}

	TInt offset = iContentDescriptionOffset + 34 + iTitleLength + iAuthorLength;

	if(iCopyrightLength - 2 <= 0 || offset + iCopyrightLength > iHeaderData->Length())

		{

		return; // empty or corrupt length

		}

	TPtrC8 copyright = iHeaderData->Mid(offset, iCopyrightLength - 2);

	HBufC* data16 = HBufC::NewLC( iCopyrightLength - 2);

	TPtr copyrightUnicode( data16->Des() );

	if ( ConvertToUnicodeL(copyright, copyrightUnicode) == KErrNone )

		{

		iContainer->AppendL( EMetaDataCopyright, copyrightUnicode );

		}

	CleanupStack::PopAndDestroy();  // data16

	}

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

// CMetaDataParserWMA::GetCommentL