/*

* 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 provides the base class for ID3v2 parsers.

*

*/

// INCLUDE FILES

#include	"MetaDataParserID3v2.h"

#include	"MetaDataParserID3v22.h"

#include	"MetaDataParserID3v23.h"

#include	"MetaDataParserID3v24.h"

#include 	"MetaDataSourceDescriptor.h"

#include    <barsc.h>

#include    <barsread.h>

#include	<TopCharacterSet.rsg>

#include 	<data_caging_path_literals.hrh>

// CONSTANTS

// (ID3v2 specification found in www.id3.org)

const TInt KID3v2HeaderLength 			= 10;

const TInt KID3v2TagLength 				= 3;

const TInt KMinimumConfidenceRequired = 90;

const TInt KMinimumJapaneseConfidenceRequired = 75;

const TUint KParseFromMemory	= 1000000; 

//Album Type

const TInt KPictureTypeOther				= 0x00;

const TInt KPictureTypePixel                = 0x01;

const TInt KPictureTypeFileIcon             = 0x02;

const TInt KPictureTypeFrontCover			= 0x03;

const TInt KPictureTypeBackCover            = 0x04;

// Album Type priority

const TInt K1stAlbumArt = KPictureTypeOther;

const TInt K2ndAlbumArt = KPictureTypeFrontCover; 

const TInt K3rdAlbumArt = KPictureTypeBackCover;

_LIT8( KID3v2Tag, "ID3" );

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

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

// CMetaDataParserID3v2::CMetaDataParserID3v2

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

// might leave.

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

//

CMetaDataParserID3v2::CMetaDataParserID3v2(

	CMetaDataSource& aSource )

	:	iSource(&aSource),

        iParseFromDescriptor(EFalse),

        iAlbumType(-1),

        iAlbumPtr(NULL)

	{

    }

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

// CMetaDataParserID3v2::CreateID3v2ParserL

// Two-phased constructor.

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

//

CMetaDataParserID3v2* CMetaDataParserID3v2::CreateID3v2ParserL(

	CMetaDataSource& aSource )

    {

#ifdef _DEBUG

	RDebug::Print(_L("CMetaDataParserID3v2::CreateID3v2ParserL"));

#endif

	TInt version = VersionL(aSource);

	CMetaDataParserID3v2* parser = NULL;

	switch ( version )

		{

		case 2:

			parser = STATIC_CAST( CMetaDataParserID3v2*, CMetaDataParserID3v22::NewL(aSource) );

			break;

		case 3:

			parser = STATIC_CAST( CMetaDataParserID3v2*, CMetaDataParserID3v23::NewL(aSource) );

			break;

		case 4:

			parser = STATIC_CAST( CMetaDataParserID3v2*, CMetaDataParserID3v24::NewL(aSource) );

			break;

		default:	// KErrNotFound

			break;

		}

	return parser;

    }

// Destructor

CMetaDataParserID3v2::~CMetaDataParserID3v2()

	{

	if(iAutoDetectChinese || iAutoDetectRussian || iAutoDetectJapanese)

		{

		delete iCharacterSet;

		delete iTopCharacterSet;

		}

	if(iParseFromDescriptor)

		{

		delete iTag;

		delete iSourceDes;

		}

	if ( iAlbumPtr )

		{

		delete iAlbumPtr;

		}

    }

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

// CMetaDataParserID3v2::ParseL

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

//

void CMetaDataParserID3v2::ParseL(

	const RArray<TMetaDataFieldId>& aWantedFields,

	CMetaDataFieldContainer& aContainer )

    {

#ifdef _DEBUG

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

#endif

	iContainer = &aContainer;

	PrepareToParseL();

	CRepository *metadataRepository = CRepository::NewL(KCRUidMetadataUtility);

	TInt err = KErrNone;

	err = metadataRepository->Get(KMetadataUtilityAutoDetectChineseChars, iAutoDetectChinese);

	if(err)

	{

		iAutoDetectChinese = EFalse;	

	}

	err = metadataRepository->Get(KMetadataUtilityAutoDetectJapaneseChars, iAutoDetectJapanese);

	if(err)

	{

		iAutoDetectJapanese = EFalse;	

	}

	delete metadataRepository;

	TLanguage lang = User::Language();

	if(lang == ELangRussian || lang == ELangUkrainian)	

		{

		iAutoDetectRussian = ETrue;	

		}

	if(iAutoDetectChinese || iAutoDetectRussian || iAutoDetectJapanese)

		{

		CreateCharacterSetsL();

		}

	// choose if want to parse from descriptor

	if(iFrameDataSize < KParseFromMemory) // 1Mb

		{

		iTag = HBufC8::NewL(iFrameDataSize);

		TPtr8 des( iTag->Des() );

		iSource->ReadL(0, des);

		iSourceDes = CMetaDataSourceDescriptor::NewL(des);

		iSource = iSourceDes;

		iParseFromDescriptor = ETrue;

		}

	if ( aWantedFields.Count() == 0 )

		{

		ParseFramesL();

		}

	else

		{

		ParseFramesL(aWantedFields);

		}

    }

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

// CMetaDataParserID3v2::ParseFramesL

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

//

void CMetaDataParserID3v2::ParseFramesL()

	{

#ifdef _DEBUG

	RDebug::Print(_L("CMetaDataParserID3v2::ParseFramesL"));

#endif

	TMetaDataFieldId fieldId;

	TInt frameSize;

	TInt frameHeaderSize = 0;

	while ( iFrameOffset < ( iFrameDataSize - 1 ) )

		{

		GetNextFieldL(fieldId, frameHeaderSize, frameSize);

		if ( frameHeaderSize == 0 )

			{

			// We have hit the padding -> no more fields to read

            break;

            }

        if ( frameSize < 0 || frameSize > ( iFrameDataSize - iFrameOffset ) )

            {

            // Invalid frame size -> stop

            break;

            }

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

		if ( fieldId != EUnknownMetaDataField )

			{

			switch ( fieldId )

				{

				case EMetaDataSongTitle:

				case EMetaDataArtist:

				case EMetaDataAlbum:

				case EMetaDataAlbumTrack:

				case EMetaDataComposer:

				case EMetaDataCopyright:

				case EMetaDataOriginalArtist:

					TRAP(err, GetTextInfoL( fieldId, frameSize ));

					break;

				case EMetaDataGenre:

					TRAP(err, GetGenreL( frameSize ));

					break;

				case EMetaDataYear:

					TRAP(err, GetTextYearL( frameSize ));

					break;

				case EMetaDataComment:

					TRAP(err, GetCommentL( frameSize ));

					break;

				case EMetaDataUrl:

					TRAP(err, GetUrlL( frameSize ));

					break;

				case EMetaDataUserUrl:

					TRAP(err, GetUserUrlL( frameSize ));

					break;

				case EMetaDataJpeg:

				    // check for 1st album art

				    if (iAlbumType != K1stAlbumArt)

				        {

	                    TRAP(err,GetJpegL( frameSize ));				        

				        }

					break;

				case EMetaDataDuration:

					TRAP(err, GetDurationL( frameSize ));

					break;

				case EMetaDataDate:

					TRAP(err, GetTextDateL( frameSize ));

					break;

				case EMetaDataRating:

					TRAP(err, GetRatingL( frameSize ));

					break;

				default:

					break;

				}

			}

		iFrameOffset += (frameSize + frameHeaderSize);

		}

    // retrieve the album art

    TRAPD (error, RetrieveAlbumArtL());

    if (error)

        {

        #ifdef _DEBUG

            RDebug::Print(_L("CMetaDataParserID3v2::ParseFramesL - RetrieveAlbumArt leave"));

        #endif        

        }

	}

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

// CMetaDataParserID3v2::ParseFramesL

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

//

void CMetaDataParserID3v2::ParseFramesL(

	const RArray<TMetaDataFieldId>& aWantedFields )

	{

#ifdef _DEBUG

	RDebug::Print(_L("CMetaDataParserID3v2::ParseFramesL - 2"));

#endif

	TMetaDataFieldId fieldId;

	TInt frameSize;

	TInt frameHeaderSize;

	while ( iFrameOffset < ( iFrameDataSize - 1 ) )

		{

		GetNextFieldL(fieldId, frameHeaderSize, frameSize);

		if ( frameHeaderSize == 0 )

			{

			// We have hit the padding -> no more fields to read

            break;

            }

        if ( frameSize < 0 || frameSize > ( iFrameDataSize - iFrameOffset ) )

            {

            // Invalid frame size -> stop

            break;

            }

		TInt err = KErrNone; 

		if ( fieldId != EUnknownMetaDataField )

			{

            // Look for it in the wanted field array

            TInt count( aWantedFields.Count() );

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

                {

                if ( aWantedFields[ i ] == fieldId )

                    {

					switch ( fieldId )

						{

						case EMetaDataSongTitle:

						case EMetaDataArtist:

						case EMetaDataAlbum:

						case EMetaDataAlbumTrack:

						case EMetaDataComposer:

						case EMetaDataCopyright:

						case EMetaDataOriginalArtist:

							TRAP(err, GetTextInfoL( fieldId, frameSize ));

							break;

						case EMetaDataGenre:

							TRAP(err, GetGenreL( frameSize ));

							break;

						case EMetaDataYear:

							TRAP(err, GetTextYearL( frameSize ));

							break;

						case EMetaDataComment:

							TRAP(err, GetCommentL( frameSize ));

							break;

						case EMetaDataUrl:

							TRAP(err, GetUrlL( frameSize ));

							break;

						case EMetaDataJpeg:

		                    // check for 1st album art

		                    if (iAlbumType != K1stAlbumArt)

		                        {

		                        TRAP(err,GetJpegL( frameSize ));                        

		                        }

							break;

						case EMetaDataUserUrl:

							TRAP(err, GetUserUrlL( frameSize ));

							break;

						case EMetaDataDuration:

							TRAP(err, GetDurationL( frameSize ));

							break;

						case EMetaDataDate:

							TRAP(err, GetTextDateL( frameSize ));

							break;

						case EMetaDataRating:

							TRAP(err, GetRatingL( frameSize ));

							break;

						default:

							break;

						}

					}

				}

			}

		iFrameOffset += (frameSize + frameHeaderSize);

		}

	// retrieve the album art

    TRAPD (error, RetrieveAlbumArtL());

    if (error)

        {

        #ifdef _DEBUG

            RDebug::Print(_L("CMetaDataParserID3v2::ParseFramesL-2 - RetrieveAlbumArt leave"));

        #endif        

        }

	}

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

// CMetaDataParserID3v2::RetrieveAlbumArtL

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

//	

void CMetaDataParserID3v2::RetrieveAlbumArtL()

    {

    // If album art exists, add to container

    if ( iAlbumPtr != NULL )

        {

        TPtr8 des( iAlbumPtr->Des() );       

        TPtrC8 pic = des.Mid(iAlbumOffset);

        TInt length = pic.Length();

        if ( length )

            {

            iContainer->AppendL( EMetaDataJpeg, pic );

            }

        // reset the album related variables

        iAlbumType = -1;

        iAlbumOffset = 0;

        delete iAlbumPtr;

        iAlbumPtr = NULL;

        }

    }

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

// CMetaDataParserID3v2::Handlev2GetGenreL

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

//

void CMetaDataParserID3v2::HandleV2GetGenreL( TInt aSize, TInt aKID3v2FrameHeaderLength, TInt aKID3v2GenreNameLength )

	{

	#ifdef _DEBUG

	RDebug::Print(_L("CMetaDataParserID3v2::GetGenreL"));

	#endif

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

	TPtr8 des( frame->Des() );

	iSource->ReadL( iFrameOffset + aKID3v2FrameHeaderLength, des, aSize );

	if ( des.Length() < aSize )

		{

		// Partial frame

		User::Leave( KErrCorrupt );

		}

	TInt encoding = (TInt) (des.Left(1))[0];

	TPtrC8 info = StripTrailingZeroes( des.Mid(1), encoding);

	TInt length = info.Length();

	if(length <= 0)

		{

		CleanupStack::PopAndDestroy();  // frame

		return;

		}

	else 

		{

		length = (length > aKID3v2GenreNameLength) ? length : aKID3v2GenreNameLength;

		}

	HBufC8* genreData = HBufC8::NewLC( length );

	TPtr8 temp( genreData->Des() );

	temp.Copy(info);

	if ( encoding == 0 )

		{

		   if ( temp[0] == KID3v2format )

			{

			//temp.Delete(0,1); 

			TLex8 lex(temp.Ptr() + 1);

			TInt genreID = 0;

			TInt err = lex.Val(genreID);	

			if(err != KErrNone)

				{

					CleanupStack::PopAndDestroy(2);  // genreData, frame

					return;

				}

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

				{

				temp.FillZ(0);

				MapID3GenreToStringL(genreID,temp);

				}

			}

			if( length )

			 {

			 HBufC* data16 = HBufC::NewLC( length );

		 	 TPtr unicode( data16->Des() );

		 	 if ( ConvertToUnicodeL(encoding, temp, unicode) == KErrNone )

				{

					iContainer->AppendL( EMetaDataGenre, unicode );

				}

			 CleanupStack::PopAndDestroy(data16);  // data16

			 }

		}

	else // non ASCII 

		{

		HBufC* dataGen16 = HBufC::NewLC( length );

		TPtr unicodeGen( dataGen16->Des() );

		if ( ConvertToUnicodeL(encoding, temp, unicodeGen) == KErrNone )

			{

			if (temp.Length() <= 2)

			    {

		        CleanupStack::PopAndDestroy(3);  // dataGen16, genreData, frame

				return;			    

			    }

			temp = temp.Mid(2);

			if(temp[0] == KID3v2format)

				{

				TLex16 lex(unicodeGen.Ptr()+1);

				TInt val=0;

				TInt err = lex.Val(val);

				if(err != KErrNone)

					{

					CleanupStack::PopAndDestroy(3);  // dataGen16, genreData, frame

					return;

					}

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

					{

					unicodeGen.FillZ(0);

					MapID3GenreToStringL(val,unicodeGen);

					}

				}

			iContainer->AppendL( EMetaDataGenre, unicodeGen );				

			}

		CleanupStack::PopAndDestroy(dataGen16);  // dataGen16

		}

	CleanupStack::PopAndDestroy(genreData);  // genreData

	CleanupStack::PopAndDestroy(frame);  // frame	

	}

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

// CMetaDataParserID3v2::VersionL

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

//

TInt CMetaDataParserID3v2::VersionL(

	CMetaDataSource& aSource )

	{

	TInt size = 0;

	aSource.Size( size );