/*

* 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 of CHuiVg10TextureProcessor.

*                CHuiVg10TextureProcessor is a concrete implementation of a texture

*                processor for OpenVG 1.0

*

*/

#include "HuiVg10TextureProcessor.h"  // Class definition

#include "HuiVg10PBufferSurface.h"

#include "HuiVg10RenderPlugin.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiStatic.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/HuiImage.h"

#include "HuiRenderSurface.h"

#include <VG/openvg.h>

CHuiVg10TextureProcessor* CHuiVg10TextureProcessor::NewL(CHuiEnv& aEnv)

    {

    CHuiVg10TextureProcessor* self = CHuiVg10TextureProcessor::NewLC(aEnv);

    CleanupStack::Pop(self);

    return self;

    }

CHuiVg10TextureProcessor* CHuiVg10TextureProcessor::NewLC(CHuiEnv& aEnv)

    {

    CHuiVg10TextureProcessor* self = new (ELeave) CHuiVg10TextureProcessor(aEnv);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CHuiVg10TextureProcessor::CHuiVg10TextureProcessor(CHuiEnv& aEnv)

        : CHuiTextureProcessor(aEnv)

    {

    }

void CHuiVg10TextureProcessor::ConstructL()

    {

    }

CHuiVg10TextureProcessor::~CHuiVg10TextureProcessor()

    {

    }

void CHuiVg10TextureProcessor::BlurL(const THuiTextureHandle& aSrc, THuiTextureHandle& aDest,

                                     TInt aFilterSize, TInt aFlags)

    {

    // By default, use a quarter of the original size.

    TSize originalSize = aSrc.Size();

    return BlurL(aSrc, aDest,

                 TSize(originalSize.iWidth / 2, originalSize.iHeight / 2),

                 aFilterSize, aFlags);

    }

void CHuiVg10TextureProcessor::BlurL(const THuiTextureHandle& aSrc,

                                     THuiTextureHandle& aDest,

                                     const TSize& /*aPreferredSize*/,

                                     TInt aFilterSize, TInt /*aFlags*/)

    {

    if (!aSrc.HasContent())

        {

        return;

        }

    VGImage src  = (VGImage)aSrc.SegmentName(0);

    if (src == VG_INVALID_HANDLE)

        {

        return;

        }

    // If src and dest overlap, openvg cannot handle it. Create temp source as workaround.

    if (aSrc.Name() == aDest.Name())

        {

    	TInt width  = vgGetParameteri(src, VG_IMAGE_WIDTH);

    	TInt height = vgGetParameteri(src, VG_IMAGE_HEIGHT);

	    VGImage tempsrc = vgCreateImage(VG_sRGBA_8888_PRE, width, height, 

	                                  VG_IMAGE_QUALITY_FASTER | VG_IMAGE_QUALITY_NONANTIALIASED);

	    VGImage dest = (VGImage)aDest.SegmentName(0);

		if (tempsrc == VG_INVALID_HANDLE)

			{

			HUI_DEBUG(_L("CHuiVg10TextureProcessor::BlurL() - Unable to allocate tempsrc texture."));

			return;

			}		

        // Copy from dest to tempsrc

        vgCopyImage(tempsrc, 0, 0, dest, 0, 0, width, height, VG_FALSE);

        if (dest != VG_INVALID_HANDLE)

            {

            vgGaussianBlur(dest, tempsrc, aFilterSize / 3.0f, aFilterSize / 3.0f, VG_TILE_PAD);                    

            }

        vgDestroyImage(tempsrc);            

        return;

        }

    if (!aDest.SegmentCount() || !aDest.SegmentName(0))

    	{

    	// No destination texture, so we must create a new one

    	// TODO: Refactor this to a more proper place

    	TInt width  = vgGetParameteri(src, VG_IMAGE_WIDTH);

    	TInt height = vgGetParameteri(src, VG_IMAGE_HEIGHT);

	    VGImage image = vgCreateImage(VG_sRGBA_8888_PRE, width, height, 

	                                  VG_IMAGE_QUALITY_FASTER | VG_IMAGE_QUALITY_NONANTIALIASED);

		if (image == VG_INVALID_HANDLE)

			{

			HUI_DEBUG(_L("CHuiVg10TextureProcessor::BlurL() - Unable to allocate blurred texture."));

			return;

			}

		aDest.SetName(image);

		aDest.SetSize(TSize(width, height));

    	}

    VGImage dest = (VGImage)aDest.SegmentName(0);

    // TODO: EBlurFlagWhite and EBlurFlagBlack

    if (src == VG_INVALID_HANDLE || dest == VG_INVALID_HANDLE)

        {

        return;

        }

    vgGaussianBlur(dest, src, aFilterSize / 3.0f, aFilterSize / 3.0f, VG_TILE_PAD);

    HUI_VG_INVARIANT();

    }

void CHuiVg10TextureProcessor::BlurSegmentedL(const MHuiSegmentedTexture& aSrc,

                       THuiTextureHandle& aDest,

                       TInt aFilterSize, TInt aFlags)

{

    BlurL(aSrc.Handle(), aDest, aFilterSize, aFlags);

}

void CHuiVg10TextureProcessor::BlurSegmentedL(const MHuiSegmentedTexture& aSrc, 

                       THuiTextureHandle& aDest,

                       const TSize& aPreferredSize,

                       TInt aFilterSize, TInt aFlags)

{

    BlurL(aSrc.Handle(), aDest, aPreferredSize, aFilterSize, aFlags);

}

void CHuiVg10TextureProcessor::Release()

    {

    HUI_DEBUG(_L("CHuiVg10TextureProcessor::Release() - Destroying processing buffer."));

    }

void CHuiVg10TextureProcessor::RestoreL()

    {

    HUI_DEBUG(_L("CHuiVg10TextureProcessor::RestoreL() - Called."));

    }