/*

* 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 files

#include <hal.h> 

#include "IEBitmapLoader.h"

#include "IEFileLoader.h"

#include "IEEngineUtils.h"

_LIT8(KMimeMbm, "image/x-epoc-mbm");

_LIT8(KMimeJpeg, "image/jpeg");

#define USE_EXIF_TN

#define USE_EXIF_TN_CROP

//#define USE_EXIF_TN_EXT_CROP

#ifdef USE_EXIF_TN

#include <iclextjpegapi.h>  // For CExtJpegDecoder

#endif

const TInt KMemoryThresholdForSuperZoom = 12*1024;

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

CIEBitmapLoader* CIEBitmapLoader::NewL(RFs& aFileServer, MBitmapLoaderObserver& aBitmapLoaderObserver, RCriticalSection* aCritical)

{

 	CIEBitmapLoader* self = new (ELeave) CIEBitmapLoader(aFileServer, aBitmapLoaderObserver, aCritical);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

}

CIEBitmapLoader::~CIEBitmapLoader()

    {

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

  	if(iImageDecoder)

  	    {

  	    iImageDecoder->Cancel();

		delete iImageDecoder;

		iImageDecoder = NULL;	

        }

    if (iExifBitmap)

        {

        delete iExifBitmap;

        iExifBitmap = NULL;

        }

#ifdef DECODE_FROM_BUFFER    

    if(iSourceData) 

        {

        delete iSourceData;

        iSourceData = NULL;

        }

#endif

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

  	}

CIEBitmapLoader::CIEBitmapLoader(RFs& aFileServer, MBitmapLoaderObserver& aBitmapLoaderObserver, RCriticalSection* aCritical)

    //:CActive(EPriorityLow),    

    :CActive(EPriorityStandard),

    //:CActive(EPriorityUserInput),

    //:CActive(CActive::EPriorityHigh),

    iFileServer(aFileServer), 

    iBitmapLoaderObserver(aBitmapLoaderObserver),

#ifdef DECODE_FROM_BUFFER    

    iSourceData(NULL), 

#endif        

    iCritical(aCritical)

    {

    }

void CIEBitmapLoader::ConstructL()

    {

	CActiveScheduler::Add(this);

	iExifTn = NULL;

	iImageDecoder = NULL;

	iImageArrayMode = EImages;

	iOutputBitmap = NULL;

	iExifBitmap = NULL;

#ifdef GET_DECODER_UID

	decoderUid = CIEEngineUtils::GetImageDecoderUid();	

#else

	decoderUid = KNullUid;

#endif

    }

void CIEBitmapLoader::CropImageL(CFbsBitmap* aOutput, CFbsBitmap* aInput) const

    {

    const TInt KMaxScanLine = 320 * 3;

    TSize inputSize = aInput->SizeInPixels();

    TSize outputSize = aOutput->SizeInPixels();

    TDisplayMode mode = aOutput->DisplayMode();

    // need to have same display mode and output cannot be bigger

    if (mode != aInput->DisplayMode() || 

        outputSize.iWidth > inputSize.iWidth ||

        outputSize.iHeight > inputSize.iHeight)

        User::Leave(KErrNotSupported);

    TInt len = CFbsBitmap::ScanLineLength(outputSize.iWidth, mode);

    TBuf8<KMaxScanLine> buf;

    if (len > KMaxScanLine)

        {

        User::Leave(KErrOverflow);

        }

    TPoint point((inputSize.iWidth - outputSize.iWidth + 1) / 2,

                 (inputSize.iHeight - outputSize.iHeight + 1) / 2);

    for (TInt i = 0;i < outputSize.iHeight;i++, point.iY++)

        {

        aInput->GetScanLine(buf, point, outputSize.iWidth, mode);

        aOutput->SetScanLine(buf, i);

        }

    }

void CIEBitmapLoader::RunL()

    {

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

    SetPriority(EPriorityStandard);

    iThumbRes = ENotDefined;

	TInt error = iStatus.Int();

	DP1_IMAGIC(_L("CIEBitmapLoader::RunL - Error: %d"),error);

	if(iImageDecoder)

	    {

        delete iImageDecoder;

        iImageDecoder = NULL;   

	    }

#ifdef DECODE_FROM_BUFFER    

    if(iSourceData) 

        {

        delete iSourceData;

        iSourceData = NULL;

        }

#endif

#ifdef USE_EXIF_TN

    if (iExifTn)

        {

        delete iExifTn;

        iExifTn = NULL;

        }   

	if(iUseExifTn && iImageData && error == KErrNone) 

	    {

	    iImageData->SetImageReady(EExifThumb, ETrue);

	    // Crop exif thumbnail

	    if (iExifBitmap && iOutputBitmap)

	        {

	        TRAP(error, CropImageL(iOutputBitmap, iExifBitmap));

	        }

	    }

	if (iExifBitmap)

	    {

	    delete iExifBitmap;

	    iExifBitmap = NULL;

	    }

    iOutputBitmap = NULL;

#endif

	iBitmapLoaderObserver.BitmapsLoadedL(error);

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

    }

void CIEBitmapLoader::DoCancel()

    {

    }

TInt CIEBitmapLoader::RunError(TInt aError)

    {

    DP1_IMAGIC(_L("CIEBitmapLoader::RunError - Error: %d"),aError);

    return KErrNone;

    }

void CIEBitmapLoader::GetOneBitmapL(CImageData* aImageData, CFbsBitmap* aBitmap, TThumbSize aThumbRes)

    {

    DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL++"));

    DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d"), aThumbRes);

    ASSERT(iImageDecoder == NULL);    

    iThumbRes = aThumbRes;

    TBool thumbnailExists = ETrue;

    //TBool isFileJpg = ETrue;

    iUseExifTn = EFalse;

    iImageData = aImageData;

    iOutputBitmap = aBitmap;

#ifdef USE_EXIF_TN    

    CExtJpegDecoder* extImageDecoder = NULL;

#endif    

    TFileName fileName;

    if(aThumbRes == EFullSize)

        {

        if(iImageData->IsImageReady(EFullSize))

            {

            //SetPriority(EPriorityUserInput);

            iImageData->GetFileName(fileName, EFullSize);

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);

            }

        else

            {

            //If TN is not ready we just return

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);

            thumbnailExists = EFalse;

            //iBitmapLoaderObserver.BitmapsLoadedL(KErrNotFound);

            User::Leave(KErrNotFound);

            return;

            }

        }

    else if(aThumbRes == ESize128x128)

        {

#ifdef USE_64X64_BITMAP_TN

        //isFileJpg = EFalse;

        iImageData->GetFileName(fileName, ESize128x128);

        DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);

        TInt error = aBitmap->Load(fileName);

        if (error == KErrNone)

            {

            SetPriority(EPriorityUserInput);

            SetActive();

            TRequestStatus* status = &iStatus;

            User::RequestComplete(status, KErrNone);

            return;

            }

#ifdef USE_EXIF_TN

        else if(iImageData->IsImageReady(EFullSize))

            {

            iUseExifTn = ETrue;

            iImageData->GetFileName(fileName, EFullSize);

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);

            }

#endif

        else

            {

            //If TN is not ready we just return

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);

            thumbnailExists = EFalse;     

            iImageData->SetImageReady(EExifThumb, EFalse);

            User::Leave(KErrNotFound);

            return;

            }

#else

        if(iImageData->IsImageReady(ESize128x128))

            {

            SetPriority(EPriorityUserInput);

            //isFileJpg = EFalse;

            iImageData->GetFileName(fileName, ESize128x128);

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);

            }

#ifdef USE_EXIF_TN

        //else if(iImageData->IsImageReady((TThumbSize)(EFullSize|EExifThumb)))

        else if(iImageData->IsImageReady(EExifThumb))

            {

            SetPriority(EPriorityUserInput);

            iUseExifTn = ETrue;

            iImageData->GetFileName(fileName, EFullSize);

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);

            }

#endif

        else

            {

            //If TN is not ready we just return

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);

            thumbnailExists = EFalse;

            iImageData->SetImageReady(EExifThumb, EFalse);

            //iBitmapLoaderObserver.BitmapsLoadedL(KErrNotFound);

            User::Leave(KErrNotFound);

            return;

            }

#endif

        }

    else if(aThumbRes == ESize512x512)

        {

        if(iImageData->IsImageReady(ESize512x512))

            {

            iImageData->GetFileName(fileName, ESize512x512);

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);

            }

        else

            {

            //If TN is not ready we just return

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);

            thumbnailExists = EFalse;

            iImageData->SetImageReady(EExifThumb, EFalse);

            User::Leave(KErrNotFound);

            return;

            }

        }

    else if(aThumbRes == ESize32x32)

        {

        if(iImageData->IsImageReady(ESize32x32))

            {

            //isFileJpg = EFalse;

            iImageData->GetFileName(fileName, ESize32x32);

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);

            TInt error = aBitmap->Load(fileName);

            if (error == KErrNone)

                {

                SetPriority(EPriorityUserInput);

                SetActive();

                TRequestStatus* status = &iStatus;

                User::RequestComplete(status, KErrNone);

                return;

                }

            }

#ifdef USE_EXIF_TN

        else if(iImageData->IsImageReady(EFullSize))

            {

            iUseExifTn = ETrue;

            iImageData->GetFileName(fileName, EFullSize);

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);

            }

#endif

        else

            {

            //If TN is not ready we just return

            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);

            thumbnailExists = EFalse;     

            iImageData->SetImageReady(EExifThumb, EFalse);

            User::Leave(KErrNotFound);

            return;

            }

        }

    if(thumbnailExists)

        {

        TInt error = KErrNone;

#ifdef USE_EXIF_TN

        if (iUseExifTn)

            {

            ASSERT(iExifTn == NULL);

            TRAP(error, iExifTn = CIEEngineUtils::ReadExifThumbnailL(iFileServer, fileName));

            DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - create decoder"));

            if (error == KErrNone)

                {

                DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL data size: %d"), iExifTn->Length());

                TRAP(error, extImageDecoder = CExtJpegDecoder::DataNewL(iFileServer, *iExifTn, /*KMimeJpeg,*/ CImageDecoder::EOptionNone));

                iImageDecoder = extImageDecoder;

                }

            else

                {

                DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - no exif thumb"));

                iImageData->SetImageReady(EExifThumb, EFalse);

                }

            DP2_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - Image exif thumb decoder - TN res: %d, error: %d"), aThumbRes, error);

            }

        else

#endif

            {

            DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - create decoder"));

            /*CExtJpegDecoder * extImageDecoder;

            TRAP(error, iImageDecoder = extImageDecoder = CExtJpegDecoder::FileNewL(

                    CExtJpegDecoder::EHwImplementation,

                    iFileServer, 

                    fileName,

                    CImageDecoder::EPreferFastDecode));*/

#ifdef DECODE_FROM_BUFFER    

            if(iSourceData) 

                {

                delete iSourceData;

                iSourceData = NULL;

                }

            RFile jpgFile;

            TInt fileSize;

            User::LeaveIfError(jpgFile.Open(iFileServer, fileName, 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,

                    CImageDecoder::TOptions(CImageDecoder::EPreferFastDecode|CImageDecoder::EOptionAlwaysThread),

                    KNullUid, 

                    KNullUid, 

                    decoderUid);

#else

            TRAP(error, iImageDecoder = CImageDecoder::FileNewL(

                    iFileServer, 

                    fileName,

                    //CImageDecoder::EPreferFastDecode,

                    CImageDecoder::TOptions(CImageDecoder::EPreferFastDecode|CImageDecoder::EOptionAlwaysThread),

                    KNullUid,

                    KNullUid,

                    decoderUid));

#endif

            }

        if(error != KErrNone)

            {

            DP2_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - Image Decoder - TN res: %d, error: %d"), aThumbRes, error);

            delete iImageDecoder;

            iImageDecoder = NULL; 

#ifdef USE_EXIF_TN

            if (iExifTn)

                {

                delete iExifTn;

                iExifTn = NULL;

                }

#endif

//            iBitmapLoaderObserver.BitmapsLoadedL(error);

            User::Leave(error);

            return;

            }

        TFrameInfo frameInfo = iImageDecoder->FrameInfo();

        if(aThumbRes == ESize128x128)

            iImageDecoder->SetDecoderThreadPriority(/*EPriorityNormal*/EPriorityMuchMore);

        else

            iImageDecoder->SetDecoderThreadPriority(EPriorityLess);

#ifdef _IMAGIC_DEBUG

        TInt mem = 0;

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

#endif

        DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - #1"));        

        TSize frameSize = frameInfo.iFrameCoordsInPixels.Size();

        //If we are loading full resolution image, we have to create smaller target bitmap 

        //to save memory and to improve speed of further image processing

        if(aThumbRes == EFullSize)

            {

            TInt mem = 0;

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

            if(mem < KMemoryThresholdForSuperZoom*1024)

                {

                //User::Leave(KErrNoMemory);

#ifdef USE_OOM            	

                ROomMonitorSession oomMonitor;

                oomMonitor.Connect();

                TInt errorCode = oomMonitor.RequestFreeMemory( 1024*KMemoryThresholdForSuperZoom );

                if ( errorCode != KErrNone )

                    {

                    // try one more time 

                    errorCode = oomMonitor.RequestFreeMemory( 1024*KMemoryThresholdForSuperZoom );

                    }

                oomMonitor.Close();

#endif                

                }

            //TSize tgtSize(1024, 1024);

            //DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - #3"));

            //TargetDecodingSize(tgtSize, frameSizue);

            if(frameSize.iHeight >= 1024 || frameSize.iWidth >= 1024)

                {

                frameSize.iHeight = Min(1024, iBitmapLoaderObserver.GetGleMaxRes());

                frameSize.iWidth = Min(1024, iBitmapLoaderObserver.GetGleMaxRes());

                }

            else

                {

                frameSize.iHeight=512;

                frameSize.iWidth=512;

                }

            }   

        // Crop thumbnail if aspect ratio is not same as full size image

#ifdef USE_EXIF_TN

#ifdef USE_EXIF_TN_CROP

        if (iUseExifTn)

            {

#ifdef USE_EXIF_TN_EXT_CROP              

            TInt cap;

            TRAP(error, cap = extImageDecoder->CapabilitiesL());

            if (error == KErrNone && cap & CExtJpegDecoder::ECapCropping)

#endif                

                {

                TReal aspectRatio = aImageData->GetAspectRatio();

                TReal thumbAspectRatio = TReal(frameSize.iWidth) / frameSize.iHeight; 

                // calculate final frame size

                //if (frameSize.iWidth / frameSize.iHeight != size.iWidth / size.iHeight)

                if (thumbAspectRatio != aspectRatio)

                    {

                    TRect finalFrameRect;

                    finalFrameRect.SetSize(frameSize);

                    if (thumbAspectRatio < aspectRatio)

                        {

                        TInt h = frameSize.iWidth / aspectRatio;

                        h += h & 1;

                        finalFrameRect.SetHeight(h);

                        }

                    else

                        {

                        TInt w = frameSize.iHeight * aspectRatio;

                        w += w & 1;

                        finalFrameRect.SetWidth(w);

                        }