/*
* Copyright (c) 2005 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:
*
*/

#include "CMIDImageDecoder.h"
#include "LcdFbsImage.h"
#include <j2me/jdebug.h>

CMIDImageDecoder::CMIDImageDecoder(RFs& aFsSession, TDisplayMode aDisplayMode)
        : CActive(CActive::EPriorityStandard), iRFsSession(aFsSession), iDisplayMode(aDisplayMode)
{
    CActiveScheduler::Add(this);
    iRFsSession = aFsSession;
}

void CMIDImageDecoder::ConstructL()
{
    iDecoder = CBufferedImageDecoder::NewL(iRFsSession);
}

CMIDImageDecoder::~CMIDImageDecoder()
{
    Cancel();
    ASSERT(NULL == iCallback);
    delete iBitmapImage;
    delete iDecoder;
}

void CMIDImageDecoder::AppendL(const TDesC8& aBuffer)
{
    TInt err = KErrNone;

    if (iState == EStart)
    {
        TRAP(err, iDecoder->OpenL(aBuffer, CImageDecoder::EOptionPngMissingiENDFail));

        if (err == KEComErrNoInterfaceIdentified || err == KErrNotFound)
        {
            // If the format is unrecognised AND the first 2 bytes are 0 then we assume it
            // is a WBMP. This is a requirement of the below defect.
            // The first two bytes of other formats (e.g. ico) may also begin with 0, 0
            // but they should have already been recognised by the first call to OpenL
            if (aBuffer[0] == 0 && aBuffer[1] == 0)
            {
                delete iDecoder;
                iDecoder = NULL;
                iDecoder = CBufferedImageDecoder::NewL(iRFsSession);
                DEBUG("* CMIDImageDecoder::AppendL - Format can't be fully identified, assuming this is WBMP");
                _LIT8(KWBMPMimeType, "image/vnd.wap.wbmp");
                TRAP(err, iDecoder->OpenL(aBuffer, KWBMPMimeType, CImageDecoder::EOptionPngMissingiENDFail));
            }
        }

        if ((err != KErrUnderflow) && (err != KEComErrNoInterfaceIdentified) && (err != KErrNotFound))
        {
            //
            // something's gone wrong that we can't fix by appending more data
            //
            User::LeaveIfError(err);
        }
        iState = EOpenPending;
    }
    else
    {
        iDecoder->AppendDataL(aBuffer);

        if (!iDecoder->ValidDecoder())
        {
            TRAP(err, iDecoder->ContinueOpenL());
            if ((err == KErrUnderflow) || (err == KEComErrNoInterfaceIdentified) || (err == KErrNotFound))
            {
                // decoder or framework needs more data to determine codec.
                return;
            }

            //
            // If something else has gone wrong then we can't fix by appending more data
            //
            User::LeaveIfError(err);
        }
    }

    if (iDecoder->ValidDecoder())
    {
        if (!iDecoder->IsImageHeaderProcessingComplete())
        {
            iDecoder->ContinueProcessingHeaderL();
            if (iDecoder->IsImageHeaderProcessingComplete())
            {
                iState = EOpenComplete;
            }
        }
        else
        {
            iState = EOpenComplete;
        }
    }
}

void NullPointer(TAny* aPtr)
{
    * static_cast<TAny**>(aPtr) = NULL;
}

void CMIDImageDecoder::DecodeL(MMIDImageObserver* aCallback)
{
    //
    // If we are asked to decode, but have not yet managed to process the
    // image header we leave with KErrCorrrupt indicating that we think
    // the encoded image data is corrupt.
    //
    if (iState < EOpenComplete)
    {
        User::Leave(KErrCorrupt);
    }
    ASSERT(NULL == iCallback);
    CleanupStack::PushL(TCleanupItem(NullPointer, &iCallback));
    iCallback = aCallback;
    ConvertL();
    CleanupStack::Pop();
}

void CMIDImageDecoder::Complete(TInt aResult)
{
    if (iCallback)
    {
        iCallback->DecodeComplete(aResult);
        iCallback = NULL;
    }
}

void CMIDImageDecoder::ConvertL()
{
    iState = EConvertPending;

    if (NULL == iBitmapImage)
    {
        const TFrameInfo& frameInfo = iDecoder->FrameInfo();

        TSize size = frameInfo.iOverallSizeInPixels;

        // S60: Set the colormode of the bitmap to be exactly as the phone's display.
        // This will cause CLcdImage class just to duplicate the handle of this image,
        // and not converting the pixels from the image's original color format to phone's color format.
        // The image is needed to be in the same color format as the phone's display so BitBlt() is the most efficient.
        //
        // Decoding directly to 16MA does not work in 5.0 HW. It works only in emulator and not for JPEG.
        // The image decoders need to fix this.
        // We decode to 16MU still and then a conversion from 16MU->16MA will be done
        //
        // Insufficient information available to load image in its natural format.

        TDisplayMode colorMode = frameInfo.iFrameDisplayMode;
        TDisplayMode alphaMode = ENone;

        if (frameInfo.iFlags & TFrameInfo::ETransparencyPossible)
        {
            if (frameInfo.iFlags & TFrameInfo::EAlphaChannel)
            {
                alphaMode = EGray256;
            }
            else
            {
                alphaMode = EGray2;
            }
        }

        //
        // This step is the most likely to fail in low memory conditions.
        //
        CLcdFbsImage* fbsImage = CLcdFbsImage::NewL(size, colorMode, alphaMode);
        CleanupStack::PushL(fbsImage);
        iBitmapImage = new(ELeave) CMIDBitmapImage(*fbsImage);
        CleanupStack::Pop(fbsImage);
    }

    CFbsBitmap* colorBitmap = iBitmapImage->ColorBitmap();
    CFbsBitmap* alphaBitmap = iBitmapImage->AlphaBitmap();

    if (alphaBitmap)
    {
        iDecoder->Convert(&iStatus, *colorBitmap, *alphaBitmap, 0);
    }
    else
    {
        iDecoder->Convert(&iStatus, *colorBitmap, 0);
    }
    SetActive();
}

void CMIDImageDecoder::Dispose()
{
    delete this;
}

MMIDBitmapImage* CMIDImageDecoder::BitmapImage() const
{
    return iBitmapImage;
}

void CMIDImageDecoder::RunL()
{
    ASSERT(iState == EConvertPending);
    Complete(iStatus.Int());
}

TInt CMIDImageDecoder::RunError(TInt aError)
{
    ASSERT(KErrNone == aError);   // should never happen
    return aError;
}

void CMIDImageDecoder::DoCancel()
{
    ASSERT(iState == EConvertPending);
    iDecoder->Cancel();
}