/*

* Copyright (c) 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: Juha Kauppinen, Mika Hokkanen

* 

* Description: Photo Browser

*

*/

#include <exifmodify.h>

#include <BAUTILS.H>

#include "IEEngineUtils.h" 

#include "ImagicConsts.h"

#include "debug.h"

#include <exifread.h>

#include <ExifUtility.h> 

#include <ICLExif.h> 

//#include <iclextjpegapi.h>  // For CExtJpegDecoder

#define KJpegDecIVAUidValue 0x10272C10

#define KJpegOptUidValue 0x101FF555

EXPORT_C CIEEngineUtils::CIEEngineUtils(RFs& aFs)

    : iFs(aFs)

    {

    } 

EXPORT_C CIEEngineUtils::~CIEEngineUtils()

    {

    }

/* Generating IETNFileName with complete path */

EXPORT_C void CIEEngineUtils::GenerateThumbnailFileName(

        TThumbSize aTNResolution,

        const TDesC& aSavedFileName, 

        TDes &aIETNFileName)

    {

    TFileName tmpName;

    TParse parser;

    switch(aTNResolution)

        {

        case ESize512x512:

            {

            parser.Set(aSavedFileName, NULL, NULL);

            tmpName = parser.DriveAndPath();//only path name

            tmpName.Append(K512x512TNFilePath);

            tmpName.Append(parser.NameAndExt());

            tmpName.Append(K512x512Ext);

            aIETNFileName.Copy(tmpName);

            break;

            }

        case ESize128x128:

           {

           parser.Set(aSavedFileName, NULL, NULL);

           tmpName = parser.DriveAndPath();//only path name

           tmpName.Append(K128x128TNFilePath);

           tmpName.Append(parser.NameAndExt());

           tmpName.Append(K128x128Ext);

           aIETNFileName.Copy(tmpName);

           break;

           }

        case ESize32x32:

           {

           parser.Set(aSavedFileName, NULL, NULL);

           tmpName = parser.DriveAndPath();//only path name

           tmpName.Append(K32x32TNFilePath);

           tmpName.Append(parser.NameAndExt());

           tmpName.Append(K32x32Ext);

           aIETNFileName.Copy(tmpName);

           break;

           }

        default:

           ASSERT(0);

           break;

        };

    }

EXPORT_C void CIEEngineUtils::DeleteThumbnails(TDesC& aFileName, RFs& aFs)

    {

    TThumbSize res[] = { ESize512x512, ESize128x128, ESize32x32 };

    for (TInt i = 0;i < sizeof(res)/ sizeof(TThumbSize);i++)

        {

        TFileName thumbFileName;

        GenerateThumbnailFileName(res[i], aFileName, thumbFileName);

        BaflUtils::DeleteFile(aFs, thumbFileName);

        }    

    }

/*Creating TN Folder */

EXPORT_C TInt CIEEngineUtils::CreateTNFolder(RFs aFs, const TDesC& aTNPath)

    {

    TInt error = KErrNone;

    if( !BaflUtils::PathExists( aFs, aTNPath ) )

        {

        error = aFs.MkDirAll( aTNPath );

        error = aFs.SetAtt( aTNPath, KEntryAttHidden, NULL );

        }

    return error;

    }

// Writes face coordinates to Exif data if faces was found

EXPORT_C TInt CIEEngineUtils::AddFaceCoordinate(const TFileName aFilename, RArray<TRect>& aCordArray)

    {

    DP0_IMAGIC(_L("CIEEngineUtils::AddFaceCoordinate++"));

    // Read first current maker note to new array from given file

    RArray<TRect> newCordArray;

    ReadFaceCoordinatesL(aFilename, newCordArray);

    // Append existing coords to new coords array

    for(TInt i=0; i<newCordArray.Count(); i++)

        {

        aCordArray.Append(newCordArray[i]);

        }

     // Write all coords to file exif data manufactorer note

    WriteFaceCoordinatesL(aFilename, aCordArray);

    newCordArray.Close();

    DP0_IMAGIC(_L("CIEEngineUtils::AddFaceCoordinate--"));

    return KErrNone;

    }

EXPORT_C HBufC8* CIEEngineUtils::ReadExifMakerNoteL(const TDes &aFileName)

    {

    DP0_IMAGIC(_L("CIEEngineUtils::ReadExifMakerNoteL++"));

    HBufC8* exif = ReadExifHeaderL(iFs, aFileName);

    CleanupStack::PushL( exif );

    CExifRead* exifRead = CExifRead::NewL(exif->Des(), CExifRead::ENoJpeg);

    CleanupStack::PushL( exifRead );

    // Get required data from the Exif image...

    /*TUint32  xRes;

    TUint32  yRes;

    exifRead->GetPixelXDimension(xRes);

    exifRead->GetPixelYDimension(yRes);*/  

    HBufC8* makerNote = exifRead->GetMakerNoteL();

    CleanupStack::PushL( makerNote );

    CleanupStack::Pop( makerNote );

    CleanupStack::PopAndDestroy( exifRead );

    CleanupStack::PopAndDestroy( exif );

    DP0_IMAGIC(_L("CIEEngineUtils::ReadExifMakerNoteL--"));

    return makerNote;

    }

EXPORT_C TInt CIEEngineUtils::RemoveFaceCoordinate(const TFileName a128x128TNFileName, RArray<TRect>& aCordArray)

    {

    DP0_IMAGIC(_L("CIEEngineUtils::RemoveFaceCoordinate++"));

    //Read first current make note

    HBufC8* makerNote = ReadExifMakerNoteL(a128x128TNFileName);

    // Allocate buffer for coords to be removed

    HBufC8* heapComment = HBufC8::NewL(100);

    TPtr8 ptrCoords = heapComment->Des();

    //Copy coords to be removed to descriptor

    for(TInt i=0; i < aCordArray.Count(); i++)

        {

        ptrCoords.AppendNum(aCordArray[i].iTl.iX);

        ptrCoords.Append(' ');

        ptrCoords.AppendNum(aCordArray[i].iTl.iY);

        ptrCoords.Append(' ');

        ptrCoords.AppendNum(aCordArray[i].iBr.iX );

        ptrCoords.Append(' ');

        ptrCoords.AppendNum(aCordArray[i].iBr.iY);

        ptrCoords.Trim();

        }

    //Find coordinates from maker note

    TPtr8 tmpPtr = makerNote->Des();

    TInt res = tmpPtr.Find(ptrCoords);

    if(res == KErrNotFound)

        return res;

    //Remove coordinates from maker note

    TInt l = ptrCoords.Length();

    tmpPtr.Delete(res, ptrCoords.Length()+1);

    //Find number of faces from maker note and update it

    _LIT8(KNumberOfFace, "#");

    res = tmpPtr.Find(KNumberOfFace);

    TLex8 lex(makerNote->Ptr());

    lex.SkipAndMark(res+1);

    TInt faceCount = 0;

    lex.Val(faceCount);

    //Check lenght of number of faces string

    TInt length = 0;

    //TInt aFaceNumber = 1;

    if(faceCount < 10)

        length = 1;

    else

        length = 2;

    HBufC8* numberOfFaces = HBufC8::NewL(length);

    TPtr8 FaceNroPtr = numberOfFaces->Des();

    FaceNroPtr.AppendNum(faceCount-1);

    tmpPtr.Replace(res+1, length, FaceNroPtr);

    //TPtr8 numberOfFaces;

    delete numberOfFaces;

    //numberOfFaces.Copy();

    // 1. Read JPEG image from the file to a buffer...

    RFile file;

    User::LeaveIfError( file.Open( iFs, a128x128TNFileName, EFileWrite ) );

    CleanupClosePushL( file );

    TInt size = 0;

    file.Size(size);

    HBufC8* jpegImage = HBufC8::NewL( size );

    CleanupStack::PushL( jpegImage );

    TPtr8 bufferDes( jpegImage->Des() );

    User::LeaveIfError( file.Read( bufferDes ) );

    CleanupStack::Pop( jpegImage );

    CleanupStack::PopAndDestroy();

    CleanupStack::PushL( jpegImage );

    file.Close();

    // 2. Instantiate Exif modifier in ECreate mode...

    CExifModify* modify = CExifModify::NewL( jpegImage->Des(), CExifModify::EModify );

    CleanupStack::PushL( modify );

    //3. Insert (Set) at least the mandatory Exif data.

    //TInt descSize = 300;

    //HBufC8* heapComment = HBufC8::NewL(descSize);

    TPtr8 ptr = makerNote->Des();

    modify->SetMakerNoteL(ptr);

    //modify->SetMakerNoteL(makerNote->Des());

    // 4. Get the new Exif image...

    // If zero length descriptor is given instead of jpeg->Des(), then only the

    // Exif meta data is returned.

    //HBufC8* newExif = modify->WriteDataL( jpegImage->Des() );

    HBufC8* newExif;

    TRAPD(err, newExif = modify->WriteDataL( jpegImage->Des() ));

    if(err != KErrNone)

        {

        TInt i=0;

        }

    //TPtr8 tmp = newExif->Des();

    User::LeaveIfError( file.Replace( iFs, a128x128TNFileName, EFileWrite ) );

    //Write Exif and jpeg image back to jpeg file

    User::LeaveIfError(file.Write(*newExif));

    // Process the new Exif data

    delete newExif;

    newExif = NULL;

    // 5. Delete the modifier instance...

    CleanupStack::PopAndDestroy( modify );

    CleanupStack::PopAndDestroy( jpegImage );

    file.Close();

    DP0_IMAGIC(_L("CIEEngineUtils::RemoveFaceCoordinate--"));

    return KErrNone;

    }

EXPORT_C void CIEEngineUtils::WriteFaceCoordinatesL(const TFileName a512x512TNFileName, RArray<TRect>& aCordArray)

    {

    DP1_IMAGIC(_L("CIEEngineUtils::WriteFaceCoordinatesL a512x512TNFileName = %S ++"), &a512x512TNFileName);

    TInt error = KErrNone;

    RFile tnFile;

    TInt size = 0;

    //Check that coords got from IDL makes sense. Eg. not out of image area etc.

    /*TSize tnSize;

    iImageDecoder->GetImageSizeL(iCurrentImageData->iMGTN_320x320_Filename, tnSize);

    TInt brx;

    TInt count = aCordArray.Count();

    TBool removed = EFalse;

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

        {

        brx = aCordArray[i].iBr.iX;

        brx = aCordArray[i].iBr.iY;

        brx = aCordArray[i].iTl.iX;

        brx = aCordArray[i].iTl.iY;

        if(aCordArray[i].iTl.iX >= aCordArray[i].iBr.iX || aCordArray[i].iTl.iY >= aCordArray[i].iBr.iY)

            {

            aCordArray.Remove(i);

            removed = ETrue;

            }

        if(removed)

            count = aCordArray.Count();

        }

    */

    User::LeaveIfError(tnFile.Open(iFs, a512x512TNFileName, EFileRead));

    tnFile.Size(size);

    if(size <= 0) User::Leave(KErrUnderflow); // May be more meaningful error code shud be returned

    HBufC8* imageData = HBufC8::NewL(size);

    CleanupStack::PushL(imageData);

    TPtr8 imageDataPtr = imageData->Des();

    User::LeaveIfError(tnFile.Read(imageDataPtr));

    tnFile.Close();

    // Create the exifmodifier instance

    CExifModify* exifModifier = CExifModify::NewL(imageDataPtr, CExifModify::ECreate);

    CleanupStack::PushL(exifModifier);

    //3. Insert (Set) at least the mandatory Exif data...

    exifModifier->SetXResolutionL( 123, 1 ); 

    exifModifier->SetYResolutionL( 512, 1 ); 

    exifModifier->SetResolutionUnitL( 2 );

    exifModifier->SetYCbCrPositioningL( 1 );

    exifModifier->SetComponentsConfigurationL( 1, 2, 3, 0 );

    exifModifier->SetColorSpaceL( 1 );

    exifModifier->SetPixelXDimensionL( 512 );

    exifModifier->SetPixelYDimensionL( 512 );

    TInt descSize = aCordArray.Count()*4*4 + 32+10; // Be careful calculating like this!!!

    HBufC8* heapComment = HBufC8::NewL(descSize);

    CleanupStack::PushL(heapComment);

    TPtr8 ptr = heapComment->Des();

    ptr.Append(KFaceCoordsHeader);

    ptr.Append(KSpace);

    ptr.Append(KFaceCoordsImagicVersion);

    ptr.Append(KSpace);

    ptr.Append(KHash);

    //Set number of faces detected to Exif data

    if(aCordArray.Count() == 0)

        ptr.Append(KZero);

    else

        {

        ptr.AppendNum(aCordArray.Count());

        ptr.Append(KSpace);

        for(TInt i=0; i<aCordArray.Count(); i++)

            {

            //TInt size = ptr.Size();

            ptr.AppendNum(aCordArray[i].iTl.iX);

            ptr.Append(KSpace);

            ptr.AppendNum(aCordArray[i].iTl.iY);

            ptr.Append(KSpace);

            ptr.AppendNum(aCordArray[i].iBr.iX);

            ptr.Append(KSpace);

            ptr.AppendNum(aCordArray[i].iBr.iY);

            ptr.Append(KSpace);

            }    

        }

    exifModifier->SetMakerNoteL(ptr);

    HBufC8* newImageData = exifModifier->WriteDataL(imageDataPtr); // newImageData contains the image data with the modified exif data

    CleanupStack::PushL(newImageData);

    if(newImageData == NULL)

        User::Leave(KErrNotFound); // Better error code should be returned

    TPtr8 newImageDataPtr = newImageData->Des();

    // Create the new thumbnail image with modified exif data

    User::LeaveIfError(tnFile.Replace(iFs, a512x512TNFileName, EFileWrite));

    User::LeaveIfError(tnFile.Write(newImageDataPtr));

    tnFile.Flush();

    tnFile.Close();

    CleanupStack::PopAndDestroy(4);

    DP0_IMAGIC(_L("CIEEngineUtils::WriteFaceCoordinatesL --"));

    }

EXPORT_C void CIEEngineUtils::ReadFaceCoordinatesL(const TFileName a512x512TNFileName, RArray<TRect>& aCordArray)

    {

    DP1_IMAGIC(_L("CIEEngineUtils::ReadFaceCoordinatesL, a512x512TNFileName = %S ++"), &a512x512TNFileName);

    TInt count = aCordArray.Count();

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

        aCordArray.Remove(0);

    HBufC8* imageData = ReadExifHeaderL(iFs, a512x512TNFileName);

    CleanupStack::PushL(imageData);

    CExifRead* exifReader;

    exifReader = CExifRead::NewL(imageData->Des(), CExifRead::ENoJpeg);

    CleanupStack::PushL(exifReader);

    HBufC8* makerNoteData = exifReader->GetMakerNoteL();

    TPtr8 makerNoteDataPtr = makerNoteData->Des();

    // No valid face information

    if (makerNoteDataPtr.Find(KFaceCoordsHeader) != 0)

        User::Leave(KErrNotFound);

    // 31 is the length of the string KFaceCoordsHeader+KSpace+KFaceCoordsImagicVersion+KSpace+KHash

    makerNoteDataPtr.Delete(0, 31);

    TRect rect(0,0,0,0);

    TLex8 lex(makerNoteDataPtr.Ptr());

    TInt faceCount = 0;

    lex.Val(faceCount);

    if(faceCount > 0)

        {

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

            {

            lex.SkipSpaceAndMark(); 

            lex.Val(rect.iTl.iX);

            lex.SkipSpaceAndMark(); 

            lex.Val(rect.iTl.iY);

            lex.SkipSpaceAndMark(); 

            lex.Val(rect.iBr.iX);

            lex.SkipSpaceAndMark(); 

            lex.Val(rect.iBr.iY);

            aCordArray.Append(rect);

            DP4_IMAGIC(_L("Rect(%d, %d, %d, %d)"), rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY);

            rect = TRect(0,0,0,0);

            }

        aCordArray.SortSigned();

        }

    CleanupStack::PopAndDestroy(2);

    DP0_IMAGIC(_L("CIEEngineUtils::ReadFaceCoordinatesL --"));

    }

EXPORT_C void CIEEngineUtils::GetModifiedTimeL(const TDes &aFileName, TTime& aTime)

    {

    DP0_IMAGIC(_L("CIEEngineUtils::GetFileModifiedTimeL++"));

    // Read file modified date

    RFile file;

    TInt error = file.Open(iFs, aFileName , EFileRead);

    DP1_IMAGIC(_L("CIEEngineUtils::GetFileModifiedTimeL - file open error = %d"), error);

    User::LeaveIfError(error);

    file.Modified(aTime);

    file.Close();

    DP0_IMAGIC(_L("CIEEngineUtils::GetFileModifiedTimeL--"));

    }

EXPORT_C void CIEEngineUtils::GetImageSizeL(const TDes &aFileName, TSize& aSize)

    {

    DP0_IMAGIC(_L("CIEEngineUtils::GetImageSizeL++"));

    CImageDecoder* imageDecoder = CImageDecoder::FileNewL(iFs, aFileName);

    TFrameInfo frameInfo = imageDecoder->FrameInfo();

    aSize = frameInfo.iFrameCoordsInPixels.Size();

    delete imageDecoder;

    imageDecoder = NULL;   

    DP2_IMAGIC(_L("CIEEngineUtils::GetImageSizeL-- [%d x %d]"), aSize.iWidth, aSize.iHeight);

    }

EXPORT_C HBufC8* CIEEngineUtils::ReadExifHeaderL(RFs& aFs, const TDesC &aFileName) 

    {

    DP0_IMAGIC(_L("CIEEngineUtils::ReadExifHeaderL++"));

    RFile file;

    User::LeaveIfError(file.Open(aFs, aFileName, EFileRead|EFileShareReadersOnly));

    CleanupClosePushL(file);

    TInt size;

    file.Size(size);

    size = Min(size, 64 * 1024);    // TODO use exact exif size

    HBufC8* exif = HBufC8::NewL(size);

    CleanupStack::PushL(exif);

    TPtr8 bufferPtr(exif->Des()); 

    User::LeaveIfError(file.Read(bufferPtr));

    CleanupStack::Pop(exif); // exif

    CleanupStack::PopAndDestroy(); // file

    DP0_IMAGIC(_L("CIEEngineUtils::ReadExifHeaderL--"));

    return exif;

    }

EXPORT_C HBufC8* CIEEngineUtils::ReadExifThumbnailL(RFs& aFs, const TDesC& aFileName)

    {

    DP1_IMAGIC(_L("CIEEngineUtils::ReadExifThumbnailL++ %S"), &aFileName);

    HBufC8* exif = ReadExifHeaderL(aFs, aFileName);

    CleanupStack::PushL(exif);

    // Instantiate Exif reader

    CExifRead* exifRead = CExifRead::NewL(*exif, CExifRead::ENoJpeg);

    CleanupStack::PushL(exifRead);

    // Get required data from the Exif image

    HBufC8* exifThumb = exifRead->GetThumbnailL();

    CleanupStack::PushL(exifThumb);

    /*TUint32 w, w2, h, h2;

    exifRead->GetThumbnailXResolution(w, w2);

    exifRead->GetThumbnailYResolution(h, h2);*/