/*

* Copyright (c) 2008-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:    Texture Manager component/Decodes the Image in step for large sized images

 *

*/

// INCLUDE FILES

#include "glxbitmapdecoderwrapper.h"

#include <glxtracer.h>      //  For Log

#include <bitmaptransforms.h>

#include <imageconversion.h>

#include <ExifRead.h>

#include <glxlog.h>

#include <hal.h>

#include <hal_data.h>

#include <mglxcache.h>

#include <oommonitorsession.h>

#include <e32math.h>

#include <apgcli.h>

namespace

    {

    const TInt KGlxDecodingThreshold = 3000000;

    const TInt KGlxDecodingThresholdDimension = 2000;

    // Photos low_ram_threshold [8.637 MB] as in oomconfig.xml

    const TInt KGlxCriticalRAMForPhotos = 9056550;

    const TInt KGlxDecodeBitmapFactor = 3;

    _LIT(KMimeJpeg,"image/jpeg");

    _LIT(KMimeJpg,"image/jpg");

    }

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

// Two-phased constructor.

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

//

CGlxBitmapDecoderWrapper* CGlxBitmapDecoderWrapper::NewL(

        MGlxBitmapDecoderObserver* aObserver)

    {

    TRACER("CGlxBitmapDecoderWrapper::NewL()");

    CGlxBitmapDecoderWrapper* self = new (ELeave) CGlxBitmapDecoderWrapper();

    CleanupStack::PushL(self);

    self->ConstructL(aObserver);

    CleanupStack::Pop(self);

    return self;

    }

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

// Constructor

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

//

CGlxBitmapDecoderWrapper::CGlxBitmapDecoderWrapper() :

    CActive(EPriorityLow)

    {

    TRACER("CGlxBitmapDecoderWrapper::CGlxBitmapDecoderWrapper()");

    }		

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

// Destructor

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

//

CGlxBitmapDecoderWrapper::~CGlxBitmapDecoderWrapper()

    {

    TRACER("CGlxBitmapDecoderWrapper::~CGlxBitmapDecoderWrapper()");

    iFs.Close();

    Cancel();

    if (iImageDecoder)

        {

        delete iImageDecoder;

        iImageDecoder = NULL;

        }

    if (iImagePath)

        {

        delete iImagePath;

        iImagePath = NULL;

        }

    }

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

// ConstructL

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

void CGlxBitmapDecoderWrapper::ConstructL(MGlxBitmapDecoderObserver* aObserver)

    {

    TRACER("CGlxBitmapDecoderWrapper::ConstructL ");

    iObserver = aObserver;

    User::LeaveIfError(iFs.Connect());

    CActiveScheduler::Add( this );

    }

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

// DoDecodeImageL

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

void CGlxBitmapDecoderWrapper::DoDecodeImageL(const TDesC& aSourceFileName,

        TInt aIndex)

    {

    TRACER("CGlxBitmapDecoderWrapper::DoDecodeImageL()");

    GLX_LOG_URI("CGlxBitmapDecoderWrapper::DoDecodeImageL(%S)",

            &aSourceFileName);

    iThumbnailIndex = aIndex;

#ifdef _DEBUG

    iStartTime.HomeTime();

#endif                          

    if (iImageDecoder)

        {

        delete iImageDecoder;

        iImageDecoder = NULL;

        }

    CImageDecoder::TOptions options =

            (CImageDecoder::TOptions) (CImageDecoder::EOptionNoDither

                    | CImageDecoder::EOptionAlwaysThread);

    // Use extended JPEG decoder

    GLX_DEBUG1("DoDecodeImageL:: EHwImplementation" );

    TRAPD( err, iImageDecoder = CExtJpegDecoder::FileNewL(

                    CExtJpegDecoder::EHwImplementation, iFs,

                    aSourceFileName, options ) );

    GLX_DEBUG2("DoDecodeImageL:: EHwImplementation (%d)", err);

    if (KErrNone != err)

        {

        TRAP(err,iImageDecoder = CExtJpegDecoder::FileNewL(

                        CExtJpegDecoder::ESwImplementation, iFs,

                        aSourceFileName, options ) );

        GLX_DEBUG2("DoDecodeImageL:: ESwImplementation (%d)", err);

        if (KErrNone != err)

            {

            GLX_DEBUG1("DoDecodeImageL::CImageDecoder");

            // Not a JPEG - use standard decoder

            iImageDecoder = CImageDecoder::FileNewL(iFs, aSourceFileName,

                    options);

            }

        }

#ifdef _DEBUG

    iStopTime.HomeTime();

    GLX_DEBUG2("*** Decoder Creation took <%d> us ***",

            (TInt)iStopTime.MicroSecondsFrom(iStartTime).Int64());

#endif                          

    TSize imageSize = iImageDecoder->FrameInfo().iOverallSizeInPixels;

    GLX_DEBUG3("GlxDecoderWrapper::DecodeImageL() - OverallSize: w=%d, h=%d",

            imageSize.iWidth, imageSize.iHeight);

    iOriginalSize.iWidth = imageSize.iWidth;

    iOriginalSize.iHeight = imageSize.iHeight;

    if (iBitmap)

        {

        delete iBitmap;

        iBitmap = NULL;

        }

    if (iImagePath)

        {

        delete iImagePath;

        iImagePath = NULL;

        }

    iImagePath = aSourceFileName.Alloc();

    DecodeImageL();

    }

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

// DecodeImageL

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

//

void CGlxBitmapDecoderWrapper::DecodeImageL()

    {

    TRACER("CGlxBitmapDecoderWrapper::DecodeImageL()");

    TReal32 mFactor = 1;

    TReal mFactor1 = 1;

    TReal32 mFactor2 = 1;

    //Set Size according to level and state

    TReal32 width = iOriginalSize.iWidth;

    TReal32 height = iOriginalSize.iHeight;

    if (KGlxDecodingThreshold < (width * height))

        {

        TReal tempFactor = TReal32(KGlxDecodingThreshold)

                / (width * height);

        User::LeaveIfError(Math::Sqrt(mFactor1, tempFactor));

        GLX_DEBUG2("DecodeImageL() - mFactor1 = %f", mFactor1);

        }

    if (KGlxDecodingThresholdDimension < width

            || KGlxDecodingThresholdDimension < height)

        {

        mFactor2 = TReal32(KGlxDecodingThresholdDimension) / Max(width,

                height);

        GLX_DEBUG2("DecodeImageL() - mFactor2 = %f", mFactor2);

        }

    mFactor = Min(TReal32(mFactor1), mFactor2);

    GLX_DEBUG2("DecodeImageL() - Final mFactor = %f", mFactor);

    // create the destination bitmap

    if (!iBitmap)

        {

        TInt freeMemory = 0;

        HAL::Get(HALData::EMemoryRAMFree, freeMemory);

        width *= mFactor;

        height *= mFactor;

        TInt minmemorytodecode = KGlxDecodeBitmapFactor * width * height;

        GLX_DEBUG3("DecodeImageL: minmemorytodecode=%d, freememory=%d",

                minmemorytodecode, freeMemory);

        iTargetBitmapSize.iWidth = width;

        iTargetBitmapSize.iHeight = height;

        GLX_DEBUG3("DecodeImageL: iTargetBitmapSize w=%d, h=%d",

                iTargetBitmapSize.iWidth, iTargetBitmapSize.iHeight);

        __ASSERT_DEBUG(width > 0 && height > 0, Panic(EGlxPanicIllegalArgument));      

        if (minmemorytodecode < (freeMemory - KGlxCriticalRAMForPhotos))

            {

            GLX_DEBUG1("DecodeImageL:RAM available decoding image");            

            iBitmap = new (ELeave) CFbsBitmap();

            iBitmap->Create(ReCalculateSizeL(),

                    iImageDecoder->FrameInfo().iFrameDisplayMode);

#ifdef _DEBUG

            iStartTime.HomeTime(); // Get home time

#endif                          

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

            }

        else

            {

            //case when sufficient memory is not available

            //request OOM FW to release the required memory

            GLX_DEBUG1("DecodeImageL:insufficient RAM - request OOM");

            TInt err = OOMRequestFreeMemoryL(minmemorytodecode);

            if (err == KErrNoMemory)

                {

                //if OOM fails, release Photos Cache

                GLX_DEBUG1("DecodeImageL:insufficient RAM - OOM failed"

                        " - request Cache");

                MGlxCache* cacheManager = MGlxCache::InstanceL();

                cacheManager->ReleaseRAML(ETrue);

                cacheManager->Close();

                //Try and release memory again

                err = OOMRequestFreeMemoryL(minmemorytodecode);

                }

            if (err != KErrNoMemory)

                {

                GLX_DEBUG1("DecodeImageL:Sufficient RAM available");                

                iBitmap = new (ELeave) CFbsBitmap();

                iBitmap->Create(ReCalculateSizeL(),

                        iImageDecoder->FrameInfo().iFrameDisplayMode);

#ifdef _DEBUG

                iStartTime.HomeTime(); // Get home time

#endif                          

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

                }

            else

                {

                GLX_DEBUG1("NOT ENOUGH MEMORY - "

                        "Using the Fullscreen Thumbnail For Zoom");

                //release the file held by decoder immediately.

                iImageDecoder->Cancel();

                delete iImageDecoder;

                iImageDecoder = NULL;

                //Inform the client that there is no decode happened and there we take care 

                //of showing the fullscreen thumbnail.

                iObserver->HandleBitmapDecodedL(iThumbnailIndex, NULL);

                return;

                }

            }

        SetActive();

        }

    }

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

// RunL

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

//

void CGlxBitmapDecoderWrapper::RunL()

    {

    TRACER("CGlxBitmapDecoderWrapper::RunL()");

    if( iStatus == KErrNone )

        {

        iObserver->HandleBitmapDecodedL(iThumbnailIndex,iBitmap);

        iBitmap = NULL;

        //release the file held by decoder immediately.

        GLX_DEBUG1("CGlxBitmapDecoderWrapper::RunL:Decoding Finished");

        iImageDecoder->Cancel();

        delete iImageDecoder;

        iImageDecoder = NULL;

#ifdef _DEBUG

        iStopTime.HomeTime();

        GLX_DEBUG2("*** Image Decode took <%d> us ***", 

                       (TInt)iStopTime.MicroSecondsFrom(iStartTime).Int64());            

#endif                          

        }

    }

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

// DoCancel

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

//

void CGlxBitmapDecoderWrapper::DoCancel()

    {

    TRACER("CGlxBitmapDecoderWrapper::DoCancel ");

    if(iImageDecoder)

        {

        GLX_DEBUG1("CGlxBitmapDecoderWrapper::DoCancel iImageDecoder delete");

        iImageDecoder->Cancel();

        delete iImageDecoder;

        iImageDecoder = NULL;

        }

    if(iBitmap)

        {

        delete iBitmap;

        iBitmap = NULL;

        }

    }

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

// OOMRequestFreeMemoryL

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

//

TInt CGlxBitmapDecoderWrapper::OOMRequestFreeMemoryL(TInt aBytesRequested)

    {

    TRACER("CGlxBitmapDecoderWrapper::OOMRequestFreeMemoryL");

    GLX_LOG_INFO1("CGlxBitmapDecoderWrapper::OOMRequestFreeMemoryL() "

            "aBytesRequested=%d", aBytesRequested);

    ROomMonitorSession oomMonitor;

    User::LeaveIfError(oomMonitor.Connect());

    // No leaving code after this point, so no need to use cleanup stack

    // for oomMonitor

    TInt errorCode = oomMonitor.RequestFreeMemory(aBytesRequested);

    GLX_LOG_INFO1("CGlxBitmapDecoderWrapper::OOMRequestFreeMemoryL(1) "

            "errorCode=%d",errorCode);

    if (errorCode != KErrNone)

        {

        // try one more time 

        errorCode = oomMonitor.RequestFreeMemory(aBytesRequested);

        GLX_LOG_INFO1("CGlxBitmapDecoderWrapper::OOMRequestFreeMemoryL(2) "

                "errorCode=%d",errorCode);

        }

    oomMonitor.Close();

    return errorCode;

    }

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

// DoesMimeTypeNeedsRecalculateL()

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

//

TBool CGlxBitmapDecoderWrapper::DoesMimeTypeNeedsRecalculateL()

    {

    TRACER("CGlxBitmapDecoderWrapper::DoesMimeTypeNeedsRecalculateL");

    RApaLsSession session;

    TDataType mimeType;

    TUid uid;

    User::LeaveIfError(session.Connect());

    CleanupClosePushL(session);

    User::LeaveIfError(session.AppForDocument(iImagePath->Des(), uid,

            mimeType));

    CleanupStack::PopAndDestroy(&session);

    if (mimeType.Des().Compare(KMimeJpeg) == 0 || mimeType.Des().Compare(

            KMimeJpg) == 0)

        {

        GLX_LOG_INFO("CGlxBitmapDecoderWrapper::DoesMimeTypeNeedsRecalculateL - jpeg");

        return EFalse;

        }

    else

        {

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::DoesMimeTypeNeedsRecalculateL - non jpeg");

        return ETrue;

        }

    }

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

// ReCalculateSize 

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

TSize CGlxBitmapDecoderWrapper::ReCalculateSizeL()

    {

    TRACER("CGlxBitmapDecoderWrapper::ReCalculateSizeL()");

    if (DoesMimeTypeNeedsRecalculateL())

        {

        TSize fullFrameSize = iImageDecoder->FrameInfo().iOverallSizeInPixels;

        // calculate the reduction factor on what size we need

        TInt reductionFactor = iImageDecoder->ReductionFactor(fullFrameSize,

                iTargetBitmapSize);

        // get the reduced size onto destination size

        TSize destSize;

        User::LeaveIfError(iImageDecoder->ReducedSize(fullFrameSize,

                reductionFactor, destSize));

        GLX_LOG_INFO2("CGlxBitmapDecoderWrapper::ReCalculateSizeL() "

                        "destSize=%d, %d",destSize.iWidth,destSize.iHeight);

        return destSize;

        }

    else

        {

        return iTargetBitmapSize;

        }

    }