/*

* Copyright (c) 2007-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:  SConMetadata implementation

*

*/

// INCLUDE FILES

#include <utf.h>  // for CnvUtfConverter

#include <MetaDataUtility.h>

#include <MetaDataFieldContainer.h>

#include <MetaDataField.hrh>

#include <caf/content.h>

#include <caf/data.h>

#include <ExifRead.h>

#include <ExifTag.h>

#include "sconmetadata.h"

#include "sconconmltask.h"

#include "sconpcdconsts.h"

#include "sconvideoparser.h"

#include "debug.h"

#include "sconmetadatafielddefs.h"

const TInt KBufferSize(1024);

// Size of buffer to load from file start to get EXIF thumbnail

const TInt KJpegLoadBufferSize = 65536; // 64k

const TUint32 KFieldMaxLength = 0xFFFFFFFF; // four bytes reserved for "length" information

// GPS related Exif IDs

const TUint16 KGPSLatitudeRef	= 0x01;

const TUint16 KGPSLatitude 	 	= 0x02;

const TUint16 KGPSLongitudeRef	= 0x03;

const TUint16 KGPSLongitude		= 0x04;

const TUint16 KGPSAltitudeRef	= 0x05;

const TUint16 KGPSAltitude		= 0x06;

// extensions for exif parser

_LIT(KJpgExt, ".jpg");

_LIT(KJpegExt, ".jpeg");

// extensions for audio metadata parser

_LIT(KAacExt, ".aac");

_LIT(KMp3Ext, ".mp3");

_LIT(KMp4Ext, ".mp4");

_LIT(KWmaExt, ".wma");

// extensions for video metadata parser

_LIT(KM4aExt, ".m4a");

_LIT(K3gpExt, ".3gp");

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

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

// SConMetadata::ProcessTask()

// ProcessTask

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

//

void SConMetadata::ProcessTask( CSConTask& aTask, RFs& aFs )

    {

    TRACE_FUNC_ENTRY;

    TInt err(KErrNone);

    if ( aTask.GetServiceId() == EGetMetadata )

        {

        LOGGER_WRITE_1( "SConMetadata::ProcessTask() : file %S",

            &aTask.iGetMetadataParams->iFilename );

#ifdef _DEBUG

        LOGGER_WRITE( "start.. " );

        TTimeIntervalMicroSeconds sec;

        TTime start;

        TTime end;

        start.HomeTime();

#endif

        TParsePtrC filename( aTask.iGetMetadataParams->iFilename );

        if ( filename.Ext().CompareF( KJpgExt ) == 0

            || filename.Ext().CompareF( KJpegExt ) == 0 )

            {

            // jpg file, try to read exif

            LOGGER_WRITE( "jpg file, Try to read exif" );

            TRAP( err, ReadExifDataL( aTask, aFs ) );

            }

        else if ( filename.Ext().CompareF( KMp4Ext ) == 0

            || filename.Ext().CompareF( K3gpExt ) == 0 )

        	{

        	LOGGER_WRITE( "Try to read video" );

        	TRAP( err, GetVideoMetadataL( aTask, aFs ) );

        	}

        else if ( filename.Ext().CompareF( KAacExt ) == 0

            || filename.Ext().CompareF( KM4aExt ) == 0

            || filename.Ext().CompareF( KMp3Ext ) == 0

            || filename.Ext().CompareF( KWmaExt ) == 0 )

            {

            // audio file, try to read audio

            LOGGER_WRITE( "Try to read audio" );

            TRAP( err, GetAudioMetadataL( aTask ) );

            }

        else

            {

            LOGGER_WRITE( "File extension not supported" );

            err = KErrNotSupported;

            }

#ifdef _DEBUG

        end.HomeTime();

        sec = end.MicroSecondsFrom( start );

        LOGGER_WRITE_1( "trapErr %d", err );

        LOGGER_WRITE_1( "duration: %Ld", sec.Int64() );

#endif

        }

    else

        {

        LOGGER_WRITE( "SConMetadata::ProcessTask() : not supported" );

        err = KErrNotSupported;

        }

    LOGGER_WRITE( "SConMetadata::ProcessTask() : CompleteTask" );

    TInt progress( KSConCodeTaskCompleted );        

    TBool complete ( ETrue );

    switch( err )

        {

        case KErrNone :

            progress =  KSConCodeTaskCompleted;

            break;

        case KErrNotFound :

        case KErrBadName :

            progress =  KSConCodeNotFound;

            break;

        default :

            progress = KSConCodeConflict;

            break;

        }

    aTask.SetCompleteValue( complete );

    aTask.SetProgressValue( progress );

    TRACE_FUNC_EXIT;

    }

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

// SConMetadata::GetAudioMetadataL()

// Read audio metadata

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

//

void SConMetadata::GetAudioMetadataL( CSConTask& aTask )

    {

    TRACE_FUNC_ENTRY;

    CMetaDataUtility* metadataUtil = CMetaDataUtility::NewL();

    CleanupStack::PushL( metadataUtil );

    LOGGER_WRITE( "SConMetadata::GetAudioMetadataL() : OpenFileL" );

    metadataUtil->OpenFileL( aTask.iGetMetadataParams->iFilename );

    TInt count = metadataUtil->MetaDataCount();

    LOGGER_WRITE_1( "SConMetadata::GetAudioMetadataL() : MetaDataCount %d", count );

    if ( count > 0 )

        {

        const CMetaDataFieldContainer& fields = metadataUtil->MetaDataFieldsL();

        count = fields.Count();

        CBufFlat* buffer = CBufFlat::NewL( KBufferSize );

        CleanupStack::PushL( buffer );

        buffer->Reset();

        TInt offset(0);

        // write object header

        // Item type (1 byte) + Version (1 byte) = 2 bytes

        buffer->ExpandL( offset, 2 );

        // header id

        TUint8 value( KSconMetadataHeaderAudio );

        buffer->Write( offset, TPtrC8(&value, 1) );

        offset++;

        // header version

        value = KSconMetadataHeaderVersion;

        buffer->Write( offset, TPtrC8(&value, 1) );

        offset++;

        // Add ID3 field

        value = metadataUtil->ID3Version();

        AppendTUintDataFieldL( buffer, value, KSconAudioID3Version );

        TMetaDataFieldId fieldId;

        TPtrC fieldData;

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

            {

            // get field id

            fields.FieldIdAt( i , fieldId );

            LOGGER_WRITE_2( "AudioFieldId( %d ): 0x%02x", i, fieldId );

                {

                TPtrC8 field8( fields.Field8( fieldId ) );

                AppendByteDataFieldL(

                    buffer,

                    field8,

                    AudioFieldId( fieldId ) );

                }

                {

                // get field data and add UTF-8 formatted text to buffer

                fieldData.Set( fields.At( i , fieldId ) );

                }

            }

        if ( buffer->Size() > 0 )

            {

            LOGGER_WRITE_1( "SConMetadata::GetAudioMetadataL() : buffer->Size() %d", buffer->Size() );

            if ( aTask.iGetMetadataParams->iData )

                {

                delete aTask.iGetMetadataParams->iData;

                aTask.iGetMetadataParams->iData = NULL;

                }

            //Initialize the task data buffer

            aTask.iGetMetadataParams->iData = HBufC8::NewL( buffer->Size() );

            TPtr8 dataPtr = aTask.iGetMetadataParams->iData->Des();

            buffer->Read( 0, dataPtr, buffer->Size() );

            LOGGER_WRITE_1( "SConMetadata::GetAudioMetadataL() dataPtr len: %d", dataPtr.Length());

            }

        CleanupStack::PopAndDestroy( buffer );

        }

    CleanupStack::PopAndDestroy( metadataUtil );

    TRACE_FUNC_EXIT;

    }

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

// SConMetadata::GetVideoMetadataL()

// Read video metadata

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

//

void SConMetadata::GetVideoMetadataL( CSConTask& aTask, RFs& aFs )

	{

	TRACE_FUNC_ENTRY;

	CBufFlat* buffer = CBufFlat::NewL( KBufferSize );

    CleanupStack::PushL( buffer );

    buffer->Reset();

    TInt offset(0);

    // write object header

    // Item type (1 byte) + Version (1 byte) = 2 bytes

    buffer->ExpandL( offset, 2 );

    // header id

    TUint8 value( KSconMetadataHeaderVideo );

    buffer->Write( offset, TPtrC8(&value, 1) );

    offset++;

    // header version

    value = KSconMetadataHeaderVersion;

    buffer->Write( offset, TPtrC8(&value, 1) );

    offset++;

	CSConVideoParser* videoParser = CSConVideoParser::NewLC();

	videoParser->OpenFileL( aFs, aTask.iGetMetadataParams->iFilename );

	LOGGER_WRITE( "Open completed" );

	const TUint KFormatMaxLength = 100;

	TBuf<KFormatMaxLength> formatMimeType;

    formatMimeType.Copy( videoParser->VideoFormatMimeTypeL() );

    LOGGER_WRITE_1( "formatMimeType: %S", &formatMimeType);

    AppendUtf8DataFieldL( buffer, formatMimeType, KSconVideoFormat );

    // we can't use TReal format, so convert frame rate to frames/ms (or 1000 frames/s)

	TReal32 frameRate = videoParser->VideoFrameRateL();

	const TUint KFrameRateMultiplier = 1000;

    TInt frm = frameRate * KFrameRateMultiplier; 

    LOGGER_WRITE_1( "frameRate: %f", frameRate );

    LOGGER_WRITE_1( "frm: %d", frm );

    AppendTUintDataFieldL( buffer, frm, KSconVideoFrameRate );

    TSize size;

    videoParser->VideoFrameSizeL( size );

    LOGGER_WRITE_2( "VideoFrameSizeL: %d, %d", size.iWidth, size.iHeight);

    AppendTUintDataFieldL( buffer, size.iWidth, KSconVideoFrameSizeWidth );

    AppendTUintDataFieldL( buffer, size.iHeight, KSconVideoFrameSizeHeight );

    const TUint8 KSconVideoAudioStreamMimetype	( 0x09 );

    const TUint8 KSconVideoVideoStreamMimetype	( 0x0a );

    TInt videoBitRate =  videoParser->VideoBitRateL();

    LOGGER_WRITE_1( "videoBitRate: %d", videoBitRate);

    AppendTUintDataFieldL( buffer, videoBitRate, KSconVideoVideoBitRate );

	TInt audioBitRate = videoParser->AudioBitRateL();

	LOGGER_WRITE_1( "audioBitRate: %d", audioBitRate);

	AppendTUintDataFieldL( buffer, audioBitRate, KSconVideoAudioBitRate );

	TInt durationMs = videoParser->DurationL();

	LOGGER_WRITE_1( "duration ms: %d", durationMs);

	AppendTUintDataFieldL( buffer, durationMs, KSconVideoDuration );

	TPtrC8 thumbnail = videoParser->Thumbnail();

	if ( thumbnail.Length() > 0 )

	    {

	    AppendByteDataFieldL( buffer, thumbnail, KSconVideoThumbnail );

	    }

	TPtrC audioMimeType = videoParser->AudioMimeTypeL();

	if ( audioMimeType.Length() > 0 )

		{

		AppendUtf8DataFieldL( buffer, audioMimeType, KSconVideoAudioStreamMimetype );

		}

	TPtrC videoMimeType = videoParser->VideoMimeTypeL();

	if ( videoMimeType.Length() > 0 )

		{

		AppendUtf8DataFieldL( buffer, formatMimeType, KSconVideoVideoStreamMimetype );

		}

	CleanupStack::PopAndDestroy( videoParser );

	LOGGER_WRITE( "videoParser deleted" );

	if ( buffer->Size() > 0 )

        {

        if ( aTask.iGetMetadataParams->iData )

            {

            delete aTask.iGetMetadataParams->iData;

            aTask.iGetMetadataParams->iData = NULL;

            }

        //Initialize the task data buffer

        aTask.iGetMetadataParams->iData = HBufC8::NewL( buffer->Size() );

        TPtr8 dataPtr = aTask.iGetMetadataParams->iData->Des();

        buffer->Read( 0, dataPtr, buffer->Size() );

        }

    CleanupStack::PopAndDestroy( buffer );

    TRACE_FUNC_EXIT;

	}

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

// SConMetadata::AudioFieldId()

// Map TMetaDataFieldId to KSconAudio field id

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

//

TUint8 SConMetadata::AudioFieldId( const TMetaDataFieldId fieldId )

    {

    TUint8 ret(NULL);

    switch( fieldId )

        {

        case EMetaDataSongTitle :

            ret = KSconAudioTitle;

            break;

        case EMetaDataArtist :

            ret = KSconAudioArtist;

            break;

        case EMetaDataAlbum :

            ret = KSconAudioAlbum;

            break;

        case EMetaDataYear :

            ret = KSconAudioYear;

            break;

        case EMetaDataComment :

            ret = KSconAudioComment;

            break;

        case EMetaDataAlbumTrack :

            ret = KSconAudioAlbumTrack;

            break;

        case EMetaDataGenre :

            ret = KSconAudioGenre;

            break;

        case EMetaDataComposer :

            ret = KSconAudioComposer;

            break;

        case EMetaDataCopyright :

            ret = KSconAudioCopyright;

            break;

        case EMetaDataOriginalArtist :

            ret = KSconAudioOriginalArtist;

            break;

        case EMetaDataUrl :

            ret = KSconAudioUrl;

            break;

        case EMetaDataUserUrl :

            ret = KSconAudioUserUrl;

            break;

        case EMetaDataJpeg :

            ret = KSconAudioJpeg;

            break;

        case EMetaDataVendor :

            ret = KSconAudioVendor;

            break;

        case EMetaDataRating :

            ret = KSconAudioRating;

            break;

        case EMetaDataUniqueFileIdentifier :

            ret = KSconAudioUniqueFileIdentifier;

            break;

        case EMetaDataDuration :

            ret = KSconAudioDuration;

            break;

        case EMetaDataDate :

            ret = KSconAudioDate;

            break;

        default :

            LOGGER_WRITE( "SConMetadata::AudioFieldId : ERR field not defined!" );

            break;

        }

    return ret;

    }

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

// SConMetadata::GetExifTagL( CExifRead* aReader, const TUint8 aTagID )

// This function is used to read exif data that might leave.

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

//

HBufC8* SConMetadata::GetExifTagL( CExifRead* aReader, const TUint8 aTagID )

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE_1( " aTagID: 0x%02x", aTagID );

    HBufC8* tempBuf( NULL );

    switch( aTagID )

        {

        case KSconExifThumbnail:

            tempBuf = aReader->GetThumbnailL();

            break;

        case KSconExifDescription:

            tempBuf = aReader->GetImageDescriptionL();

            break;

        case KSconExifMake:

            tempBuf = aReader->GetMakeL();

            break;

        case KSconExifModel:

            tempBuf = aReader->GetModelL();

            break;

        case KSconExifDateTime:

            tempBuf = aReader->GetDateTimeL();

            break;

        case KSconExifSoftware:

            tempBuf = aReader->GetSoftwareL();

            break;

        case KSconExifCopyright:

            tempBuf = aReader->GetCopyrightL();

            break;

        case KSconExifIsoSpeedRatings:

            tempBuf = aReader->GetIsoSpeedRatingsL();

            if ( tempBuf )

                {

                TInt isoSpeed = ReadTUint32( tempBuf->Des() );

                LOGGER_WRITE_1(" isoSpeed: %d", isoSpeed);

                delete tempBuf;

                const TInt maxLength(5);

                // no need to push on cleanupstack as leave cannot

                // happen before returning tempBuf.

                tempBuf = HBufC8::NewL(maxLength);

                TPtr8 temp = tempBuf->Des();

                temp.Num( isoSpeed );

                }

            break;

        case KSconExifDateTimeOriginal:

            tempBuf = aReader->GetDateTimeOriginalL();

            break;

        case KSconExifDateTimeDigitized:

            tempBuf = aReader->GetDateTimeDigitizedL();

            break;

        case KSconExifMakerNote:

            // makernote contents are up to the manufacturer

            // not needed.

            User::Leave( KErrNotSupported );

            break;

        case KSconExifUserComment:

            tempBuf = aReader->GetUserCommentL();

            break;

        case KSconExifRelatedSoundFile:

            tempBuf = aReader->GetRelatedSoundFileL();

            break;

        default:

            User::Leave( KErrNotSupported );

        }

    TRACE_FUNC_EXIT;

    return tempBuf;

    }

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

// SConMetadata::ReadTUint32()

// Convert 8-bit binary data to unsigned integer 

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

//

TUint32 SConMetadata::ReadTUint32( const TDesC8& aData )

    {

    TRACE_FUNC_ENTRY;