/*

* Copyright (c) 2006-2008 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:   Implementation for CHuiVg10Texture, OpenVG 1.0 Texture.

*

*/

#include <e32def.h>

#include <e32math.h>

#include "HuiVg10RenderPlugin.h"

#include "HuiVg10Texture.h"

#include "HuiVg10TextureManager.h"

#include "uiacceltk/HuiTextureHandle.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiTextureManager.h"

#include "uiacceltk/HuiTextureProcessor.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiPanic.h"

#include "huiextension.h"

// temporary hack until the openvg headers are fixed..

#ifndef OPENVG_VERSION_1_0_1

    #warning using temporary hack to define OPENVG_VERSION_1_0_1, see TSW: SKYA-7QQB8

    #define OPENVG_VERSION_1_0_1

#endif

#ifdef __NVG

    #include <EGL/egl.h>

    #include <nvg.h>

    #include <AknIconUtils.h>

    #include "HuiRenderSurface.h"

    #include "NVGIcon.h"

#endif

/**

 *  Bitmap color mode conversion.

 *

 *  @param aBitmap      Source bitmap to convert.

 *  @param aDisplayMode Target display mode.

 *  @param aCopyMode    Desired copy behavior.

 *  @returns a new bitmap with the desired display mode.

 */

static CFbsBitmap& ConvertBitmapL(const CFbsBitmap& aBitmap, TDisplayMode aDisplayMode, TBitmapCopyMode aCopyMode = EAllowDuplication, TSize aNewSize = TSize(0,0))

    {

    // Functionality moved to Texture Manager 

    // (to avoid recreating the bitmaps & bmpDevices every time)

    CHuiTextureManager& tmpMgr = CHuiStatic::Env().TextureManager();

    CHuiVg10TextureManager& textureMgr = static_cast<CHuiVg10TextureManager&>(tmpMgr);

    return textureMgr.ConvertBitmapL(aBitmap, aDisplayMode, aCopyMode, aNewSize);

    }

/**

 *  Replace the alpha channel of an EColor16MA bitmap (in-place).

 * 

 *  @param aBitmap      Destination bitmap.

 *  @param aMaskBitmap  Alpha channel source bitmap.

 */

static void ReplaceAlphaChannelL(CFbsBitmap& aBitmap, const CFbsBitmap& aMaskBitmap)

    {

    ASSERT(aBitmap.DisplayMode() == EColor16MA);

    ASSERT(aBitmap.SizeInPixels() == aMaskBitmap.SizeInPixels());

    CFbsBitmap& convMask = ConvertBitmapL(aMaskBitmap, EGray256);

    aBitmap.BeginDataAccess();

    convMask.BeginDataAccess();

    TSize size           = aBitmap.SizeInPixels();

    TUint32* dest32      = (TUint32*)aBitmap.DataAddress();

    const TUint8* src8   = (const TUint8*)convMask.DataAddress();

    TInt destStride      = CFbsBitmap::ScanLineLength(size.iWidth, aBitmap.DisplayMode()) >> 2;

    TInt srcStride       = CFbsBitmap::ScanLineLength(size.iWidth, convMask.DisplayMode());

    for (TInt y = 0; y < size.iHeight; y++)

        {

        TUint32* d      = dest32;

        const TUint8* s = src8;

        for (TInt x = 0; x < size.iWidth; x++)

            {

            *d   &= ~0xff000000;

            *d++ |= (*s++) << 24;

            }

        dest32 += destStride;

        src8   += srcStride;

        }

    aBitmap.EndDataAccess();

    convMask.EndDataAccess(ETrue);

    }

#if !defined(OPENVG_VERSION_1_0_1)

/**

 *  Convert a native Symbian EColor16MU/A bitmap to an OpenVG 1.0 equivalent (in-place).

 * 

 *  @param aBitmap      Bitmap to convert.

 */

static void ConvertPixelComponentOrdering(CFbsBitmap& aBitmap)

    {

    ASSERT(aBitmap.DisplayMode() == EColor16MA || aBitmap.DisplayMode() == EColor16MU);

    aBitmap.BeginDataAccess();

    TSize size           = aBitmap.SizeInPixels();

    TUint32* dest32      = (TUint32*)aBitmap.DataAddress();

    TInt destStride      = CFbsBitmap::ScanLineLength(size.iWidth, aBitmap.DisplayMode()) >> 2;

    for (TInt y = 0; y < size.iHeight; y++)

        {

        TUint32* d = dest32;

        for (TInt x = 0; x < size.iWidth; x++)

            {

            *d++ = (*d << 8) | ((*d & 0xff000000) >> 24);

            }

        dest32 += destStride;

        }

    aBitmap.EndDataAccess();

    }

#endif

/* Vg10Texture internal flags. */

enum

    {

    /** Content has been uploaded. */

    EFlagHasContent = 0x1,

    /** The texture has an alpha channel. */

    EFlagHasAlpha = 0x2

    };

CHuiVg10Texture* CHuiVg10Texture::NewL(CHuiVg10RenderPlugin& aRenderPlugin, const THuiTextureHandle* aExistingTexture)

    {

    CHuiVg10Texture* self = CHuiVg10Texture::NewLC(aRenderPlugin, aExistingTexture);

    CleanupStack::Pop(self);

    return self;

    }

CHuiVg10Texture* CHuiVg10Texture::NewLC(CHuiVg10RenderPlugin& aRenderPlugin, const THuiTextureHandle* aExistingTexture)

    {

    CHuiVg10Texture* self = new (ELeave) CHuiVg10Texture(aRenderPlugin);

    CleanupStack::PushL(self);

    self->ConstructL(aExistingTexture);

    return self;

    }

CHuiVg10Texture::CHuiVg10Texture(CHuiVg10RenderPlugin& aRenderPlugin)

    : iRenderPlugin(aRenderPlugin),

      iInternalFlags(0),

      iShadowEnabled(EFalse)

    {

    }

void CHuiVg10Texture::ConstructL(const THuiTextureHandle* aExistingTexture)

    {

    CHuiTexture::BaseConstructL();

    SetSegmentCountL(1);

    SetSegmentName(0, 0);

    SetSegmentSize(0, TSize(0, 0));

    SetSegmentTextureSize(0, TSize(0, 0));

    if(aExistingTexture)

        {

        // Take over the existing texture (single named texture object).

        ASSERT(aExistingTexture->SegmentCount() == 1);

        ASSERT(SegmentCount() == 1);

        SetSegmentName(0, aExistingTexture->Name());

        SetSegmentSize(0, aExistingTexture->SegmentSize(0));

        SetSegmentTextureSize(0, aExistingTexture->SegmentTextureSize(0));

        SetSize(aExistingTexture->Size());

        // Copy attributes

        const CHuiVg10Texture* vgTex = reinterpret_cast<const CHuiVg10Texture*>(aExistingTexture);

        iInternalFlags = vgTex->iInternalFlags;

        // Note: shared shadows not supported

        }

    }

CHuiVg10Texture::~CHuiVg10Texture()

    {

    Reset();

    }

TBool CHuiVg10Texture::HasAlpha() const

    {

    return (iInternalFlags & EFlagHasAlpha) != 0;

    }

TBool CHuiVg10Texture::HasContent() const

    {

    if(!CHuiTexture::HasContent())

        {

        return EFalse;

        }

    return (iInternalFlags & EFlagHasContent) != 0;

    }    

TSize CHuiVg10Texture::MaxTextureSize() const

    {

    if (iRenderPlugin.IsReleased())

        {

        HUI_DEBUG(_L("CHuiVg10Texture::MaxTextureSize() - Vg10 context not available, cannot get maximum texture size, returning (0,0)."));

        return TSize(0,0);

        }

    int maxWidth  = vgGeti(VG_MAX_IMAGE_WIDTH)-1;

    int maxHeight = vgGeti(VG_MAX_IMAGE_HEIGHT)-1;

    HUI_VG_INVARIANT();

    ASSERT(maxWidth > 0 && maxHeight > 0);

    return TSize(maxWidth, maxHeight);

    }

void CHuiVg10Texture::UploadL(const CFbsBitmap& aBitmap,

                              const CFbsBitmap* aMaskBitmap,

                              THuiTextureUploadFlags aTextureFlags)

    {

    Reset(); // Must delete old content before calling SetupSegmentsL

    TBool invalidMaskSize = (aMaskBitmap && (aBitmap.SizeInPixels() != aMaskBitmap->SizeInPixels()));

    CFbsBitmap* maskBitmap = (CFbsBitmap*)aMaskBitmap;

    if (invalidMaskSize)

        {

        maskBitmap = &ConvertBitmapL(*aMaskBitmap, aMaskBitmap->DisplayMode(), EAlwaysCopy, aBitmap.SizeInPixels());

        }

    SetupSegmentsL(aBitmap.SizeInPixels(), aBitmap.SizeInPixels(), aTextureFlags);

    SegmentUploadL(0, aBitmap, maskBitmap, aTextureFlags);

    }

void CHuiVg10Texture::UploadL(THuiTextureFormat aTextureFormat,

                              const TSize& aTextureSize,

                              const TUint8* aTextureBuffer,

                              THuiTextureUploadFlags aTextureFlags,

                              TUint aTextureBufferSize)

    {

    Reset(); // Must delete old content before calling SetupSegmentsL

    SetupSegmentsL(aTextureSize, aTextureSize, aTextureFlags);

    SegmentUploadL(0, aTextureFormat, aTextureSize, aTextureBuffer, aTextureBufferSize);

    }

void CHuiVg10Texture::PartialUploadL(THuiTextureFormat aFormat,

                                     const TPoint& aOrigin,

                                     const TSize& aSize,

                                     const TUint8* aBuffer)

    {

    ASSERT(SegmentCount() == 1);

    SegmentPartialUpload(0, aFormat, aOrigin, aSize, aBuffer);

    }

void CHuiVg10Texture::SegmentUploadL(TInt aSegment,

                                     const CFbsBitmap& aBitmap,

                                     const CFbsBitmap* aMaskBitmap,

                                     THuiTextureUploadFlags aFlags)

    {

    ASSERT(aSegment >= 0 && aSegment < SegmentCount());

    ASSERT(aBitmap.SizeInPixels() == Size());

    ASSERT(aMaskBitmap && aBitmap.SizeInPixels() == aMaskBitmap->SizeInPixels() || !aMaskBitmap);

    PushEGLContext();

    if(aSegment < 0 || aSegment >= SegmentCount())

        {

        User::Leave(KErrArgument);

        }

    // Clear any previous image data

    ResetSegment(aSegment);

#ifdef __NVG

    // Check if the bitmap is extended and has NVG data

    TUid bitmaptype = aBitmap.ExtendedBitmapType();

    TUid masktype = KNullUid;

    if (aMaskBitmap)

        {

        masktype = aMaskBitmap->ExtendedBitmapType();

        // extended bitmap and mask

        if (bitmaptype == masktype && bitmaptype != KNullUid)

            {

            SegmentUploadNvgL(aBitmap, aMaskBitmap, aFlags);

            // We now have working texture data, no need to do anything else

            PopEGLContext();

            return;

            }

        }

    else if (bitmaptype != KNullUid)

        {

        SegmentUploadNvgL(aBitmap, aMaskBitmap, aFlags);

        // We now have working texture data, no need to do anything else

        PopEGLContext();

        return;

        }

#endif

    VGImageFormat imageSourceFormat = (VGImageFormat)(-1);

    VGImageFormat imageInternalFormat = VG_sXRGB_8888; // TODO: get the most optimal image format from the renderer

    VGbitfield qualityFlags = VG_IMAGE_QUALITY_BETTER | VG_IMAGE_QUALITY_FASTER | VG_IMAGE_QUALITY_NONANTIALIASED;

    TBool hasAlpha = (aMaskBitmap != NULL);

    TBool conversionRequired = ETrue;

    TSize size = Size();

    TSize textureSize = MaxTextureSize();

    textureSize.iWidth = Min(size.iWidth, textureSize.iWidth);

    textureSize.iHeight = Min(size.iHeight, textureSize.iHeight);

    // See if there is a native color mode we could use without conversion

    switch (aBitmap.DisplayMode())

        {

        case EGray256:

            imageSourceFormat = VG_A_8;

            conversionRequired = EFalse;

            break;

        case EColor64K:

            imageSourceFormat = VG_sRGB_565;

            conversionRequired = EFalse;

            break;

        case EColor4K:

            imageSourceFormat = VG_sRGB_565;

            conversionRequired = ETrue;

            break;    

#if defined(OPENVG_VERSION_1_0_1)

        case EColor16MU:

            imageSourceFormat = VG_sXRGB_8888;

            conversionRequired = EFalse;

            break;

		case EColor16M:

            imageSourceFormat = VG_sXRGB_8888;

            conversionRequired = ETrue;

            break;

        case EColor16MA:

            imageSourceFormat = VG_sARGB_8888;

            hasAlpha = ETrue;

            conversionRequired = EFalse;

            break;

        case EColor16MAP:

            imageSourceFormat = VG_sARGB_8888_PRE;

            hasAlpha = ETrue;

            conversionRequired = EFalse;

            break;

#else // defined(OPENVG_VERSION_1_0_1)

        case EColor16MU:

		case EColor16M:

            imageSourceFormat = VG_sRGBX_8888;

            break;

        case EColor16MA:

            imageSourceFormat = VG_sRGBA_8888;

            hasAlpha = ETrue;

            break;

        case EColor16MAP:

            imageSourceFormat = VG_sRGBA_8888_PRE;

            hasAlpha = ETrue;

            break;

#endif // defined(OPENVG_VERSION_1_0_1)

        default:

#ifdef _DEBUG

            RDebug::Printf("CHuiVg10Texture::SegmentUploadL - unknown display mode %d", aBitmap.DisplayMode());

#endif

            conversionRequired = ETrue;

            imageSourceFormat = VG_sXRGB_8888;

        }

    if (aBitmap.IsCompressedInRAM() || aMaskBitmap)

        {

        conversionRequired = ETrue;

        }

    if (hasAlpha)

        {

        imageInternalFormat = VG_sRGBA_8888_PRE;

        }

    else

        {

        imageInternalFormat = imageSourceFormat;

        }

    // Create the actual image

    VGImage image = vgCreateImage(imageInternalFormat, textureSize.iWidth, textureSize.iHeight, qualityFlags);

    if (image == VG_INVALID_HANDLE)

        {

        User::Leave(KErrNoMemory);

        }

    if (!conversionRequired)

        {

        // No data conversion is required and we can upload the pixels as such

        aBitmap.BeginDataAccess();

        const void* data = aBitmap.DataAddress();

        TInt stride      = CFbsBitmap::ScanLineLength(size.iWidth, aBitmap.DisplayMode());

        vgImageSubData(image, data, stride, imageSourceFormat, 0, 0, textureSize.iWidth, textureSize.iHeight);

        aBitmap.EndDataAccess( ETrue );

        }

    else

        {

        // One or more conversion steps are needed

        if (hasAlpha)

            {

            // Alpha channel needs to be accounted for

#if defined(OPENVG_VERSION_1_0_1)

            imageSourceFormat = VG_sARGB_8888;

            CFbsBitmap& convBitmap = ConvertBitmapL(aBitmap, EColor16MA);

#else // defined(OPENVG_VERSION_1_0_1)

            imageSourceFormat = VG_sRGBA_8888;

            CFbsBitmap& convBitmap = ConvertBitmapL(aBitmap, EColor16MA);

#endif // defined(OPENVG_VERSION_1_0_1)

            // Bake the alpha channel into the converted bitmap

            if (aMaskBitmap)

                {

                if (aMaskBitmap->IsCompressedInRAM() || masktype != KNullUid)

                    {

                    CFbsBitmap& noncompressedMask = ConvertBitmapL(*aMaskBitmap, EGray256, EAlwaysCopy);

                    ReplaceAlphaChannelL(convBitmap, noncompressedMask);                                                

                    }

                 else

                    {

                    ReplaceAlphaChannelL(convBitmap, *aMaskBitmap);

                    }

                }

            #if !defined(OPENVG_VERSION_1_0_1)

                    // Match the native OpenVG 1.0 pixel component ordering

                    ASSERT(convBitmap.Handle() != aBitmap.Handle());

                    ConvertPixelComponentOrdering(convBitmap);

            #endif 

            convBitmap.BeginDataAccess();

            const void* data = convBitmap.DataAddress();

            TInt stride      = CFbsBitmap::ScanLineLength(size.iWidth, convBitmap.DisplayMode());

            vgImageSubData(image, data, stride, imageSourceFormat, 0, 0, textureSize.iWidth, textureSize.iHeight);

            convBitmap.EndDataAccess( ETrue );

            }

        else

            {

            // No alpha channel -- just opaque pixel data

#if defined(OPENVG_VERSION_1_0_1)

            TDisplayMode mode = EColor16MU;

            if (imageSourceFormat == VG_sRGB_565)

                {

                mode = EColor64K;

                }

            else if (imageSourceFormat == VG_A_8)

                {

                mode = EGray256;

                }

            else

                {

                imageSourceFormat = VG_sXRGB_8888;

                }

            CFbsBitmap& convBitmap = ConvertBitmapL(aBitmap, mode);

#else // defined(OPENVG_VERSION_1_0_1)

            imageSourceFormat = VG_sRGBX_8888;

            CFbsBitmap& convBitmap = ConvertBitmapL(aBitmap, EColor16MU);

            // Match the native OpenVG 1.0 pixel component ordering

            ASSERT(convBitmap.Handle() != aBitmap.Handle());

            ConvertPixelComponentOrdering(convBitmap);

#endif // defined(OPENVG_VERSION_1_0_1)

            convBitmap.BeginDataAccess();

            const void* data = convBitmap.DataAddress();

            TInt stride      = CFbsBitmap::ScanLineLength(size.iWidth, convBitmap.DisplayMode());

            vgImageSubData(image, data, stride, imageSourceFormat, 0, 0, textureSize.iWidth, textureSize.iHeight);

            convBitmap.EndDataAccess( ETrue );

            }

        }

    // Save the image handle

    SetSegmentName(0, (TUint)image);

    // The texture now has content.

    iInternalFlags |= EFlagHasContent;

    if (hasAlpha)

        {

        iInternalFlags |= EFlagHasAlpha;

        }

    // Keep the shadow in sync with the image contents

    if (IsShadowEnabled())

        {

        // if this fails there is nothing we can do

        // There will be no shadow if something goes wrong here

        TRAP_IGNORE( GenerateShadowL() );

        }

    PopEGLContext();

    // Wake up refresh. It is likely that the new texture will be visible on

    // the screen.

    CHuiStatic::ContinueRefresh();

    }

static void ConvertBufferRgb888TosRGBX8888(const TUint8* aSrc, TUint8* aDest, TInt aCount)

{

    while (aCount--)

        {

        *aDest++ = *aSrc++;

        *aDest++ = *aSrc++;

        *aDest++ = *aSrc++;

        *aDest++ = 0xff;

        }

}