#include <e32math.h>

#include <apgcli.h>

    {

    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");

    }

CGlxBitmapDecoderWrapper* CGlxBitmapDecoderWrapper::NewL(

        MGlxBitmapDecoderObserver* aObserver)

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

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

CGlxBitmapDecoderWrapper::CGlxBitmapDecoderWrapper() :

    CActive(EPriorityLow)

    {

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

    }		

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

    if (iImagePath)

        {

        delete iImagePath;

        iImagePath = NULL;

        }

void CGlxBitmapDecoderWrapper::DoDecodeImageL(const TDesC& aSourceFileName,

        TInt aIndex)

    {

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

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

            &aSourceFileName);

    iStartTime.HomeTime();

    CImageDecoder::TOptions options =

            (CImageDecoder::TOptions) (CImageDecoder::EOptionNoDither

                    | CImageDecoder::EOptionAlwaysThread);

    GLX_DEBUG1("DoDecodeImageL:: EHwImplementation" );

                    CExtJpegDecoder::EHwImplementation, iFs,

                    aSourceFileName, options ) );

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

    if (KErrNone != err)

                        CExtJpegDecoder::ESwImplementation, iFs,

                        aSourceFileName, options ) );

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

        if (KErrNone != err)

            GLX_DEBUG1("DoDecodeImageL::CImageDecoder");

            iImageDecoder = CImageDecoder::FileNewL(iFs, aSourceFileName,

                    options);

    iStopTime.HomeTime();

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

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

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

            imageSize.iWidth, imageSize.iHeight);

    if (iImagePath)

        {

        delete iImagePath;

        iImagePath = NULL;

        }

    iImagePath = aSourceFileName.Alloc();

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

    TReal mFactor1 = 1;

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

    if (!iBitmap)

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

        width *= mFactor;

        height *= mFactor;

        TInt minmemorytodecode = KGlxDecodeBitmapFactor * width * height;

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

        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->Create(ReCalculateSizeL(),

                    iImageDecoder->FrameInfo().iFrameDisplayMode);

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

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

            if (err == KErrNoMemory)

                GLX_DEBUG1("DecodeImageL:insufficient RAM - OOM failed"

                        " - request Cache");

                cacheManager->ReleaseRAML(ETrue);

            if (err != KErrNoMemory)

                GLX_DEBUG1("DecodeImageL:Sufficient RAM available");                

                iBitmap->Create(ReCalculateSizeL(),

                        iImageDecoder->FrameInfo().iFrameDisplayMode);

                iStartTime.HomeTime(); // Get home time

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

                GLX_DEBUG1("NOT ENOUGH MEMORY - "

                        "Using the Fullscreen Thumbnail For Zoom");

                iObserver->HandleBitmapDecodedL(iThumbnailIndex, NULL);

                return;

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

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

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

    TRACER("CGlxBitmapDecoderWrapper::DoCancel ");

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

TInt CGlxBitmapDecoderWrapper::OOMRequestFreeMemoryL(TInt aBytesRequested)

    GLX_LOG_INFO1("CGlxBitmapDecoderWrapper::OOMRequestFreeMemoryL() "

            "aBytesRequested=%d", aBytesRequested);

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

    TInt errorCode = oomMonitor.RequestFreeMemory(aBytesRequested);

    GLX_LOG_INFO1("CGlxBitmapDecoderWrapper::OOMRequestFreeMemoryL(1) "

            "errorCode=%d",errorCode);

    if (errorCode != KErrNone)

        errorCode = oomMonitor.RequestFreeMemory(aBytesRequested);

        GLX_LOG_INFO1("CGlxBitmapDecoderWrapper::OOMRequestFreeMemoryL(2) "

                "errorCode=%d",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;

        }

    }