/*

* 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 <ImageConversion.h> //CImageDecoder

#include <FBS.H> //CFbsBitmap

#include <BAUTILS.H>

//#include <IEBGPSTrace.h>

#include "IETNGenerator.h"

#include "IEBgpServerSession.h" 

#include <hal.h> 

#include "ImagicConsts.h"

#include "ieengineutils.h" 

_LIT8(KMimeJpeg, "image/jpeg");

_LIT8(KMimePng, "image/png");

#define DO_NOT_USE_SCALING

CIETNGeneratorAO* CIETNGeneratorAO::NewL(RFs& aFileServer, MIEThumbNailObserver &aObserver)

{

	CIETNGeneratorAO* self = new (ELeave) CIETNGeneratorAO(aFileServer, aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

}

CIETNGeneratorAO::~CIETNGeneratorAO()

{

    DP0_IMAGIC((_L("CIETNGeneratorAO::~CIETNGeneratorAO ++")));

 	if(IsActive())

		Cancel();

	 CancelOutStaningRequests();

	 DeleteObjects();

	 DP0_IMAGIC((_L("CIETNGeneratorAO::~CIETNGeneratorAO --")));

}

//EPriorityIdle, EPriorityLow, EPriorityStandard, EPriorityUserInput, EPriorityHigh

CIETNGeneratorAO::CIETNGeneratorAO(RFs& aFileServer, MIEThumbNailObserver &aObserver)

: iFileServer(aFileServer),

  iThumbnailObserver(aObserver),

  CActive(EPriorityStandard)

{

}

void CIETNGeneratorAO::ConstructL()

    {

    DP0_IMAGIC((_L("CIETNGeneratorAO::ConstructL ++")));

	CActiveScheduler::Add(this);

	iError = KErrNone;

	decoderUid = CIEEngineUtils::GetImageDecoderUid();

	//i512x512TnBitmap = new (ELeave) CFbsBitmap();

	DP0_IMAGIC((_L("CIETNGeneratorAO::ConstructL --")));

    }

void CIETNGeneratorAO::RunL()

    {

    DP0_IMAGIC((_L("CIETNGeneratorAO::RunL ++")));

    iError = iStatus.Int();

#ifdef _IMAGIC_DEBUG

    TInt mem = 0;

	TInt ret = HAL::Get(HALData::EMemoryRAMFree, mem);

	DP1_IMAGIC(_L("CIETNGeneratorAO::RunL - mem: %d"),mem);

#endif

	if(iError != KErrNone)

	    {

	    DeleteObjects();

        iConvertStatus = ENone;

        // inform to higher layer... and delete thumbnails we tried to create

        DP1_IMAGIC(_L("CIETNGeneratorAO::RunL - Something wrong %d"), iError);      

        iThumbnailObserver.ThumbNailGenerationCompleted(iError);

	    }

	switch (iConvertStatus)

	    {

	    case EDecoding:

	        {

	        DP0_IMAGIC((_L("CIETNGeneratorAO::RunL - EDecoding")));

	        TRAPD(err, DecodeL()); // TODO handle errors

	        if (err != KErrNone) 

	            {

	            DP1_IMAGIC((_L("CIETNGeneratorAO::RunL - EDecoding error: %d")), err);

	            iThumbnailObserver.ThumbNailGenerationCompleted(err); //ASSERT(0);

	            iConvertStatus = ENone;

	            }

	        else

	            {

#ifdef DO_NOT_USE_SCALING

	            iConvertStatus = EEncoding;

#else

	            iConvertStatus = EScaling;

#endif

                SetActive();

	            }

	        }

	        break;

	    case EScaling:

	        {

	        DP0_IMAGIC((_L("CIETNGeneratorAO::RunL - EScaling")));

	        TRAPD(err, ScaleL());

            if (err != KErrNone) 

                {

                DP1_IMAGIC((_L("CIETNGeneratorAO::RunL - EScaling error: %d")), err);

                iThumbnailObserver.ThumbNailGenerationCompleted(err); //ASSERT(0);

                iConvertStatus = ENone;

                }

            else

                {

                iConvertStatus = EEncoding;

                SetActive();

                }

	        }

	        break;

	    case EEncoding:

	        {

	        DP0_IMAGIC((_L("CIETNGeneratorAO::RunL - EEncoding")));

	        TRAPD(err, EncodeL()); // TODO handle errors

	        if (err != KErrNone)

	            {

	            DP1_IMAGIC((_L("CIETNGeneratorAO::RunL - EEncoding error: %d")), err);

                iThumbnailObserver.ThumbNailGenerationCompleted(err); //ASSERT(0);

                iConvertStatus = ENone;

	            }

	        else

	            {

	            iConvertStatus = EReady;

#ifdef USE_BITMAPS_TNS

	            if(!IsJPEG(iThumbnailSize))

	                {

	                //When saving TN as bitmap we need to complete request immeadtely 

	                //because bitmap saving is handled by CFbsBitmap class instead of image encoder

	                SetActive();

	                TRequestStatus* status = &iStatus;

	                User::RequestComplete( status, KErrNone );

	                }

	            else

	                {

	                SetActive();

	                }

#else

	            SetActive();        

#endif

	            }

	        }

	        break;

	    case EReady:

	        {

	        DP0_IMAGIC((_L("CIETNGeneratorAO::RunL - EReady")));

	        // use same image for generating smaller thumbnails

	        if (IsLargeThumbnail(iThumbnailSize))

	            {

                /*DP0_IMAGIC((_L("CIETNGeneratorAO::RunL - EScaling")));

                TRAPD(err, ScaleL());

                if (err != KErrNone)

                    ASSERT(0);// TODO handle errors   

                iConvertStatus = EEncoding;

                SetActive();*/ 

   		    }

	        if( iImageEncoder )

	            {

	            delete iImageEncoder;

	            iImageEncoder = NULL;

	            }

	        if( iBitmap )

	            {

	            iBitmap->Reset();

	            delete iBitmap;

	            iBitmap = NULL;

	            }

#ifdef DECODE_FROM_BUFFER    

	        if(iSourceData) 

	            {

	            delete iSourceData;

	            iSourceData = NULL;

	            }

#endif

	        iConvertStatus = ENone;

#ifndef USE_BITMAPS_TNS

	        WriteExifData(iThumbnailFileName, iResolutionSize);

#else

	        if(IsJPEG(iThumbnailSize))

	            {

	            TRAPD(err, WriteExifDataL(iThumbnailFileName, iThumbnailSize));

	            }

#endif

            iFileServer.SetModified(iThumbnailFileName, iSourceTime);

            iThumbnailObserver.ThumbNailGenerationCompleted(KErrNone);

            }

	        break;

        }

    DP0_IMAGIC(_L("CIETNGeneratorAO::RunL --"));

    }

TBool CIETNGeneratorAO::IsJPEG(const TSize& aResolution) const

    {

#ifdef USE_64X64_BITMAP_TN

    return (aResolution.iWidth >= 512 || aResolution.iHeight >= 512);

#else

    return (aResolution.iWidth >= 128 || aResolution.iHeight >= 128);    

#endif

    }

TBool CIETNGeneratorAO::IsLargeThumbnail(const TSize& aResolution) const

    {

    return (aResolution.iHeight >= 512);

    }

void CIETNGeneratorAO::ScaleL()

    {

    DP0_IMAGIC((_L("CIETNGeneratorAO::Scale++")));

    if ( iImageDecoder )

        {

        delete iImageDecoder;

        iImageDecoder = NULL;

        }

    if (iBitmapScaler )

        {

        delete iImageDecoder;

        iImageDecoder = NULL;

        }

    iBitmapScaler = CBitmapScaler::NewL();

    iBitmapScaler->UseLowMemoryAlgorithm(ETrue);

    TSize tgtBitmapize;

    // If we want to create high resolution thumbnail, we use 512x512 resolution

    // for low resolution TN we use size set in iResolutionSize

    if(IsLargeThumbnail(iThumbnailSize))

        {

        tgtBitmapize.iWidth = 512;

        tgtBitmapize.iHeight = 512;

        if(iSourceSize.iWidth > iSourceSize.iHeight)

            {

            // If we have wide panorama, use higher resolution to width

            if((iSourceSize.iWidth / iSourceSize.iHeight) > 1.6)

                tgtBitmapize.iWidth = 1024;

            }

        else

            {

            // If we have wide panorama, use higher resolution to height

            if((iSourceSize.iHeight / iSourceSize.iWidth) > 1.6)

                tgtBitmapize.iHeight = 1024;

            }

        }

    else

        {

        tgtBitmapize = iThumbnailSize;

        }

    // Use max quality

    iBitmapScaler->SetQualityAlgorithm(CBitmapScaler::EMaximumQuality);

    //iBitmapScaler->SetQualityAlgorithm(CBitmapScaler::EMediumQuality);

    //iBitmapScaler->SetQualityAlgorithm(CBitmapScaler::EMinimumQuality);

    DP2_IMAGIC(_L("CIETNGeneratorAO::Scale to %dx%d"), tgtBitmapize.iWidth, tgtBitmapize.iHeight);

    iBitmapScaler->Scale(&iStatus, *iBitmap, tgtBitmapize, EFalse);

    DP0_IMAGIC((_L("CIETNGeneratorAO::Scale--")));

    }

void CIETNGeneratorAO::EncodeL()

    {

    DP0_IMAGIC((_L("CIETNGeneratorAO::Encode++")));

    if (iImageDecoder )

        {

        delete iImageDecoder;

        iImageDecoder = NULL;

        }

    if( iBitmapScaler )

        {

        delete iBitmapScaler;

        iBitmapScaler = NULL;

        }

    if( iImageEncoder )

        {

        delete iImageEncoder;

        iImageEncoder = NULL;

        }

    TParse parser;

    parser.Set(iThumbnailFileName, NULL, NULL );

    TFileName tnPath = parser.DriveAndPath();

    CIEEngineUtils::CreateTNFolder(iFileServer, tnPath);

#ifdef USE_BITMAPS_TNS

    // Save Bitmap thumbnails if resolution is 128x128 or smaller

    if(!IsJPEG(iThumbnailSize))

        {

        iBitmap->Save(iThumbnailFileName);

        }

    else //if bigger than then save jpg thumbnails

#endif

        {

#if 0

        //If we had 512x512 resolution bitmap we make copy of it

        if(iBitmap->SizeInPixels().iWidth == 512 && iBitmap->SizeInPixels().iHeight == 512)

            {

            i512x512TnBitmap->Reset();

            TInt error = i512x512TnBitmap->Create(iBitmap->SizeInPixels(), EColor16M);

            TUint8* dstData = (TUint8 *)i512x512TnBitmap->DataAddress();

            TUint8* srcData = (TUint8 *)iBitmap->DataAddress();

            TInt dataSize = iBitmap->SizeInPixels().iWidth * iBitmap->SizeInPixels().iHeight;

            dataSize*=3;

            //Copy bitmap

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

                {

                dstData[i] = srcData[i];

                }

            }

#endif       

        SetJpegImageDataL();

        DP1_IMAGIC(_L("CIETNGeneratorAO::Encode - iThumbnailFileName: %S"), &iThumbnailFileName);

        iMimeString = KMimeJpeg;

        iImageEncoder = CImageEncoder::FileNewL( iFileServer, iThumbnailFileName, iMimeString );

        iImageEncoder->Convert(&iStatus, *iBitmap, iFrameImageData);

        }

    TEntry entry;

    User::LeaveIfError(iFileServer.Entry(iThumbnailFileName, entry));

    // Remember the modified time of the source file

    iSourceTime = entry.iModified;

    DP0_IMAGIC((_L("CIETNGeneratorAO::Encode--")));

    }

void CIETNGeneratorAO::DecodeL()

    {

    DP0_IMAGIC((_L("CIETNGeneratorAO::Decode++")));

    if(iImageDecoder)

        {

        delete iImageDecoder;

        iImageDecoder = NULL;   

        }

    DP1_IMAGIC((_L("CIETNGeneratorAO::Decode - Creating decoder... with filename: %S")),&iSourceFileName);

#ifdef USE_EXT_JPEG_DEC

    iImageDecoder = CExtJpegDecoder::FileNewL(iFileServer, iSourceFileName);

#else

#ifdef DECODE_FROM_BUFFER    

    if(iSourceData) {

        delete iSourceData;

        iSourceData = NULL;

    }

    RFile jpgFile;

    TInt fileSize;

    User::LeaveIfError(jpgFile.Open(iFileServer, iSourceFileName, EFileRead));

    jpgFile.Size(fileSize);

    iSourceData = HBufC8::NewL(fileSize);

    TPtr8 buffer = iSourceData->Des();

    jpgFile.Read(buffer, fileSize);

    jpgFile.Close();

    iImageDecoder = CImageDecoder::DataNewL(

            iFileServer, 

            *iSourceData, 

            CImageDecoder::EOptionNone, 

            KNullUid, 

            KNullUid, 

            decoderUid);

#else    

    iImageDecoder = CImageDecoder::FileNewL(

                                        iFileServer, 

                                        iSourceFileName, 

                                        CImageDecoder::EOptionNone, 

                                        KNullUid, 

                                        KNullUid, 

                                        decoderUid);

#endif

#endif

    iMimeString = KMimeJpeg;

#ifdef DECODE_FROM_BUFFER

    CImageDecoder::GetMimeTypeDataL( *iSourceData, iMimeString );    

#else

    CImageDecoder::GetMimeTypeFileL( iFileServer, iSourceFileName, iMimeString );

#endif

    iSourceSize = iImageDecoder->FrameInfo().iOverallSizeInPixels;

    DP2_IMAGIC((_L("CIETNGeneratorAO::Decode - image %dx%d")), iSourceSize.iWidth, iSourceSize.iHeight );

    iBitmap = new (ELeave) CFbsBitmap();

    TargetDecodingSize(iThumbnailSize, iSourceSize);

#ifdef DO_NOT_USE_SCALING

    if(IsLargeThumbnail(iThumbnailSize))

        {

        iSourceSize.iHeight=512;

        iSourceSize.iWidth=512;

        }

#endif

    TInt error = iBitmap->Create(iSourceSize, EColor16M);

    iImageDecoder->Convert(&iStatus, *iBitmap, 0);

    DP0_IMAGIC((_L("CIETNGeneratorAO::Decode - convert bitmap... OK")));

    DP0_IMAGIC((_L("CIETNGeneratorAO::Decode--")));

    }

void CIETNGeneratorAO::TargetDecodingSize(const TSize aTgtSize, TSize& aSrcSize)

    {

    DP0_IMAGIC(_L("CIETNGeneratorAO::TargetDecodingSize++"));

    DP2_IMAGIC(_L("CIETNGeneratorAO::TargetDecodingSize - Tgt %dx%d"),aTgtSize.iHeight, aTgtSize.iWidth);

    DP2_IMAGIC(_L("CIETNGeneratorAO::TargetDecodingSize - Src %dx%d"),aSrcSize.iHeight, aSrcSize.iWidth);

    // up to 32 times downscale in scaler

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

        {

        if (aSrcSize.iWidth < aTgtSize.iWidth * 2 ||

            aSrcSize.iHeight < aTgtSize.iHeight * 2) 

            {

            break;

            }

            aSrcSize.iWidth >>= 1;

            aSrcSize.iHeight >>= 1;

        }

    // Check that we do not create odd resolution size thumbnail

    if(aSrcSize.iHeight & 1)

        aSrcSize.iHeight++;

    if(aSrcSize.iWidth & 1)

        aSrcSize.iWidth++;

    DP2_IMAGIC(_L("CIETNGeneratorAO::TargetDecodingSize - New Src %dx%d"), aSrcSize.iHeight, aSrcSize.iWidth);

    DP0_IMAGIC((_L("CIETNGeneratorAO::TargetDecodingSize--")));

    }

void CIETNGeneratorAO::WriteExifDataL(const TDes &aFilename, TSize aSize)

     {

     DP0_IMAGIC(_L("CIETNGeneratorAO::WriteExifData++"));

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

     RFile file;

     User::LeaveIfError( file.Open( iFileServer, aFilename, 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::ECreate );

     CleanupStack::PushL( modify );

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

     modify->SetXResolutionL( aSize.iWidth, 1 ); 

     modify->SetYResolutionL( aSize.iHeight, 1 ); 

     modify->SetResolutionUnitL( 2 );

     modify->SetYCbCrPositioningL( 1 );

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

     modify->SetColorSpaceL( 1 );

     modify->SetPixelXDimensionL( aSize.iWidth );

     modify->SetPixelYDimensionL( aSize.iHeight );

     // 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() );

     TPtr8 tmp = newExif->Des();