/*
* 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 <bitdev.h>
#include <bitstd.h>
#include <lcdgdrv.h>
#include "LcdFbsImage.h"

#ifdef LCDGR_ACCELERATED_BITGDI
const TUid KJvmExeUid = { 0x102033E6 };
#endif

/**
 * Copy bitmap data from (aColorBitmap,aAlphaBitmap) to aFbsImage.
 */
extern void CopyBitmapsL
(
    CLcdGraphicsDriver& /* aDriver */,  // not used yet
    CLcdFbsImage&       aFbsImage,
    CFbsBitmap*         aColorBitmap,
    CFbsBitmap*         aAlphaBitmap,
    TBool               aInvertMask
);

/**
 * Create a CFbsBitmap of size aSize in displaymode aMode
 */
LOCAL_C CFbsBitmap* CreateBitmapL(const TSize& aSize, TDisplayMode aMode);

/**
 * Set alpha channel in EColor16MA mode aBitmap from aAlphaBitmap. If aAlphaBitmap is
 * in a mode other than EGray256 this procedure will create a temporary bitmap in
 * EGray256 mode and copy pixels from aAlphaBitmap into that first. It is expected
 * that aAlphaBitmap would be a binary mask.
 */
LOCAL_C void SetAlphaChannelL(CFbsBitmap* aBitmap, CFbsBitmap* aAlphaBitmap, TBool aInvert);

/**
 * Set the alpha channel in an EColor16MA mode aBitmap from an EGray256 mode
 * aGray256Bitmap.
 */
LOCAL_C void SetAlphaChannel(CFbsBitmap* aBitmap, CFbsBitmap* aGray256Bitmap, TBool aInvert);

/**
 * Copy alpha information from EColor16MA bitmap aSource, into EGray2 or EGray256
 * bitmap aTarget.
 */
LOCAL_C void GetAlphaChannelL(CFbsBitmap* aTarget, CFbsBitmap* aSource, TBool aInvert);

/**
 * Copy alpha channel from EColor16MA bitmap into an EGray256 bitmap
 */
LOCAL_C void GetAlphaChannel(CFbsBitmap* aTargetGray256, CFbsBitmap* aSourceColor16MA, TBool aInvert);

#ifdef _DEBUG
//
// debug only - check that EColor16MA aBitmap is fully opaque
//
LOCAL_C TBool CheckOpaque(CFbsBitmap* aBitmap);
#endif


/*************************************************************
 *
 * CLcdFbsImage potentially public bitmapped image class.
 *
 ************************************************************/

CLcdFbsImage* CLcdFbsImage::NewL(const TSize& aSize, TDisplayMode aColorMode, TDisplayMode aAlphaMode)
{
    CLcdFbsImage* image = new(ELeave) CLcdFbsImage;
    CleanupStack::PushL(image);
    image->iColorBitmap = CreateBitmapL(aSize, aColorMode);
    if (aAlphaMode)
    {
        image->iAlphaBitmap = CreateBitmapL(aSize, aAlphaMode);
    }
    CleanupStack::Pop(image);
    return image;
}

CLcdFbsImage* CLcdFbsImage::NewL(CFbsBitmap* aColorBitmap, CFbsBitmap* aAlphaBitmap)
{
    CLcdFbsImage* image = new(ELeave) CLcdFbsImage;

    CleanupStack::PushL(image);
    image->iColorBitmap = DuplicateBitmapL(aColorBitmap);
    if (aAlphaBitmap)
    {
        image->iAlphaBitmap = DuplicateBitmapL(aAlphaBitmap);
    }
    CleanupStack::Pop(image);

    return image;
}

CLcdFbsImage::~CLcdFbsImage()
{
    ASSERT(0 == iRefCount);
    delete iAlphaBitmap;
    delete iColorBitmap;
}

TSize CLcdFbsImage::Size() const
{
    return iColorBitmap->SizeInPixels();
}

void CLcdFbsImage::AddRef()
{
    ++iRefCount;
}

void CLcdFbsImage::RemoveRef()
{
    --iRefCount;
    if (iRefCount == 0)
    {
        delete this;
    }
}

/**
 *@return the color bitmap
 */
CFbsBitmap* CLcdFbsImage::ColorBitmap() const
{
    return iColorBitmap;
}

/**
 *@return the alpha bitmap if any
 */
CFbsBitmap* CLcdFbsImage::AlphaBitmap() const
{
    return iAlphaBitmap;
}

void CLcdFbsImage::CreateAlphaBitmapL()
{
    if (iAlphaBitmap)
    {
        User::Leave(KErrAlreadyExists);
    }

    iAlphaBitmap = CreateBitmapL(Size(), EGray256);
}

/**
 * Create a bitmap of size aSize in display mode aMode.
 */
LOCAL_C CFbsBitmap* CreateBitmapL(const TSize& aSize, TDisplayMode aMode)
{
    TInt err = KErrNotSupported;

    CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);

#ifdef LCDGR_ACCELERATED_BITGDI
    //
    // Attempt to create hardware bitmap which can be used with a
    // hardware graphics accelerator. Very few if any devices
    // appear to support RHardwareBitmap so this is very unlikely
    // to be used.
    //
    err = bitmap->CreateHardwareBitmap(aSize, aMode, KJvmExeUid);
#endif

    if (err != KErrNone)
    {
        //
        // Fallback to software only bitmap if hardware unavailable/not supported.
        //
        err = bitmap->Create(aSize, aMode);
    }

    User::LeaveIfError(err);

    CleanupStack::Pop(bitmap);

    return bitmap;
}

/**
 * Create a new bitmap in a given mode and copy the data.
 * Slowish closest match copy. We could use lcd graphics driver for some
 * of these copies but is good enough for now.
 */
CFbsBitmap* CLcdFbsImage::CopyBitmapL(CFbsBitmap* aBitmap, TDisplayMode aMode, TBool aInvert)
{
    CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);
    User::LeaveIfError(bitmap->Create(aBitmap->SizeInPixels(), aMode));
    CopyBitmapL(bitmap, aBitmap, aInvert);
    CleanupStack::Pop(bitmap);
    return bitmap;
}

/**
 * Copy bitmap content from aSource to aTarget optionally inverting.
 */
void CLcdFbsImage::CopyBitmapL(CFbsBitmap* aTarget, CFbsBitmap* aSource, TBool aInvert)
{
    CFbsBitmapDevice* device = CFbsBitmapDevice::NewL(aTarget);
    CleanupStack::PushL(device);
    CFbsBitGc* gc = NULL;
    User::LeaveIfError(device->CreateContext(gc));

    // Don't alpha blend (Either copy the alpha component or write opaque pixels)
    TInt drawMode = CGraphicsContext::EDrawModeWriteAlpha;
    if (aInvert)
    {
        // Invert pixel values - only really makes sense for binary masks
        // For EColor16MA images the alpha component is not inverted
        drawMode |= CGraphicsContext::EInvertPen;
    }

    gc->SetDrawMode(CGraphicsContext::TDrawMode(drawMode));
    gc->BitBlt(TPoint(), aSource);
    delete gc;
    CleanupStack::PopAndDestroy(device);
}

/**
 * Dup the handle. This requires an FBSERV ipc.
 */
CFbsBitmap* CLcdFbsImage::DuplicateBitmapL(CFbsBitmap* aBitmap)
{
    CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);
    User::LeaveIfError(bitmap->Duplicate(aBitmap->Handle()));
    CleanupStack::Pop(bitmap);
    return bitmap;
}

/**
 * Copy bitmap data from (aColorBitmap,aAlphaBitmap) to aFbsImage.
 */
extern void CopyBitmapsL
(
    CLcdGraphicsDriver& /* aDriver */,  // not used yet
    CLcdFbsImage&       aFbsImage,
    CFbsBitmap*         aColorBitmap,
    CFbsBitmap*         aAlphaBitmap,
    TBool               aInvertMask
)
{
    //
    // First copy the the pixel color data.
    //
    CLcdFbsImage::CopyBitmapL(aFbsImage.ColorBitmap(), aColorBitmap, EFalse);

    //
    // If target colour bitmap contains alpha channel, copy any alpha data
    // into it.
    //
    if (aFbsImage.ColorBitmap()->DisplayMode() == EColor16MA)
    {
        ASSERT(NULL == aFbsImage.AlphaBitmap());
        if (aAlphaBitmap)
        {
            SetAlphaChannelL(aFbsImage.ColorBitmap(), aAlphaBitmap, aInvertMask);
        }
#ifdef _DEBUG
        else
        {
            ASSERT(CheckOpaque(aFbsImage.ColorBitmap()));
        }
#endif
    }
    else if (aFbsImage.AlphaBitmap())
    {
        if (aAlphaBitmap)
        {
            CLcdFbsImage::CopyBitmapL(aFbsImage.AlphaBitmap(), aAlphaBitmap, EFalse);
        }
        else if (aColorBitmap->DisplayMode() == EColor16MA)
        {
            GetAlphaChannelL(aFbsImage.AlphaBitmap(), aColorBitmap, aInvertMask);
        }
    }
}


//
// Set the alpha channel in a bitmap in a mode that contains alpha
// information from an alpha bitmap.
//
// Not the cheapest, but this is hopefully an edge case.
//
// EColor16M,Gray256 is the most likely format, so a dedicated blitter
// could help.
//
LOCAL_C void SetAlphaChannelL(CFbsBitmap* aBitmap, CFbsBitmap* aAlphaBitmap, TBool aInvert)
{
    ASSERT(aBitmap->DisplayMode() == EColor16MA);
    if (aAlphaBitmap->DisplayMode() != EGray256)
    {
        CFbsBitmap* alpha = CLcdFbsImage::CopyBitmapL(aAlphaBitmap, EGray256, EFalse);
        SetAlphaChannel(aBitmap, alpha, aInvert);
        delete alpha;
    }
    else
    {
        SetAlphaChannel(aBitmap, aAlphaBitmap, aInvert);
    }
}

//
// Set the alpha channel in an EColor16MA bitmap from an EGray256
// bitmap.
//
LOCAL_C void SetAlphaChannel(CFbsBitmap* aBitmap, CFbsBitmap* aGray256Bitmap, TBool aInvert)
{
    ASSERT(aBitmap->DisplayMode()        == EColor16MA);
    ASSERT(aGray256Bitmap->DisplayMode() == EGray256);

    TAcceleratedBitmapSpec targetSpec(aBitmap);
    TAcceleratedBitmapInfo target;
    TAcceleratedBitmapSpec sourceSpec(aGray256Bitmap);
    TAcceleratedBitmapInfo source;
    TBitmapLockCount count;

    targetSpec.Lock(count);
    sourceSpec.Lock(count);

    targetSpec.GetInfo(target);
    sourceSpec.GetInfo(source);

    ASSERT(target.iSize == source.iSize);

    TUint8* tgtAddress   = target.iAddress;
    TInt    tgtLinePitch = target.iLinePitch;
    TUint8* srcAddress   = source.iAddress;
    TInt    srcLinePitch = source.iLinePitch;

    TUint32 mask = aInvert ? 0xff:0x00;
    for (TInt h=target.iSize.iHeight; --h>=0;)
    {
        TUint8*  src = srcAddress;
        TUint32* tgt = (TUint32*)tgtAddress;
        TUint32* end = tgt + target.iSize.iWidth;
        while (tgt < end)
        {
            TUint32 alpha = (*src) ^ mask;
            TUint32 pixel = *tgt;
            pixel &= 0x00ffffff;
            pixel |= (alpha << 24);
            *tgt = pixel;
            ++src;
            ++tgt;
        }
        tgtAddress += tgtLinePitch;
        srcAddress += srcLinePitch;
    }

    sourceSpec.Unlock(count);
    targetSpec.Unlock(count);
}


//
// Copy alpha information from EColor16MA bitmap aSource, into EGray2 or EGray256
// bitmap aTarget.
//
LOCAL_C void GetAlphaChannelL(CFbsBitmap* aTarget, CFbsBitmap* aSource, TBool aInvert)
{
    ASSERT(aTarget->DisplayMode() == EGray2 || aTarget->DisplayMode() == EGray256);
    if (aTarget->DisplayMode() == EGray2)
    {
        TSize size = aSource->SizeInPixels();
        CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
        CleanupStack::PushL(bitmap);
        User::LeaveIfError(bitmap->Create(size, EGray256));
        GetAlphaChannel(bitmap, aSource, aInvert);
        CFbsBitmapDevice* device = CFbsBitmapDevice::NewL(aTarget);
        CleanupStack::PushL(device);
        CFbsBitGc* context = NULL;
        User::LeaveIfError(device->CreateContext(context));
        context->BitBlt(TPoint(), bitmap);
        delete context;
        CleanupStack::PopAndDestroy(device);
        CleanupStack::PopAndDestroy(bitmap);
    }
    else
    {
        GetAlphaChannel(aTarget, aSource, aInvert);
    }
}

//
// Copy alpha channel from EColor16MA bitmap into an EGray256 bitmap
//
LOCAL_C void GetAlphaChannel(CFbsBitmap* aTargetGray256, CFbsBitmap* aSourceColor16MA, TBool aInvert)
{
    ASSERT(aTargetGray256->DisplayMode()   == EGray256);
    ASSERT(aSourceColor16MA->DisplayMode() == EColor16MA);

    TAcceleratedBitmapSpec targetSpec(aTargetGray256);
    TAcceleratedBitmapInfo target;
    TAcceleratedBitmapSpec sourceSpec(aSourceColor16MA);
    TAcceleratedBitmapInfo source;
    TBitmapLockCount count;

    targetSpec.Lock(count);
    sourceSpec.Lock(count);

    targetSpec.GetInfo(target);
    sourceSpec.GetInfo(source);

    ASSERT(target.iSize == source.iSize);

    TUint8* tgtAddress   = target.iAddress;
    TInt    tgtLinePitch = target.iLinePitch;
    TUint8* srcAddress   = source.iAddress;
    TInt    srcLinePitch = source.iLinePitch;

    TUint32 mask = aInvert ? 0xff:0x00;
    for (TInt h=target.iSize.iHeight; --h>=0;)
    {
        TUint32*  src = (TUint32*)srcAddress;
        TUint8*   tgt = (TUint8*)tgtAddress;
        TUint8*   end = tgt + target.iSize.iWidth;
        while (tgt < end)
        {
            *tgt++ = (TUint8)(((*src++)>>24)^mask);
        }
        tgtAddress += tgtLinePitch;
        srcAddress += srcLinePitch;
    }

    sourceSpec.Unlock(count);
    targetSpec.Unlock(count);
}

#ifdef _DEBUG
LOCAL_C TBool CheckOpaque(CFbsBitmap* aBitmap)
{
    ASSERT(aBitmap->DisplayMode() == EColor16MA);
    TAcceleratedBitmapSpec spec(aBitmap);
    TAcceleratedBitmapInfo info;
    TBitmapLockCount count;

    spec.Lock(count);
    spec.GetInfo(info);

    TUint8* address = info.iAddress;
    TInt    linePitch = info.iLinePitch;
    TUint32 accum = 0xff000000;

    for (TInt h=info.iSize.iHeight; --h>=0;)
    {
        TUint32* src = (TUint32*)address;
        TUint32* end = src + info.iSize.iWidth;
        while (src < end)
        {
            accum &= *src++;
        }
        address += linePitch;
    }

    spec.Unlock(count);

    return (accum == 0xff000000);
}
#endif