// Copyright (c) 2007-2009 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:
// Graphics Resource - image implementation
//

#include "sgdriver.h"

EXPORT_C TInt RSgImage::Create(const TSgImageInfo& aInfo, const TAny* aDataAddress, TInt aDataStride, const TSgAttributeArrayBase* aAttributes)
	{
	if (iImpl)
		{
		return KErrInUse;
		}
	__ASSERT_ALWAYS(gPls.iDriver, Panic(ESgPanicNoDriver));
	return gPls.iDriver->CreateImage(aInfo, aDataAddress, aDataStride, aAttributes, iImpl);
	}

EXPORT_C TInt RSgImage::Create(const TSgImageInfo& aInfo, const RSgImage& aImage, const TSgAttributeArrayBase* aAttributes)
	{
	if (iImpl)
		{
		return KErrInUse;
		}
	__ASSERT_ALWAYS(gPls.iDriver, Panic(ESgPanicNoDriver));
	return gPls.iDriver->CreateImage(aInfo, static_cast<XSgImage*>(aImage.iImpl), aAttributes, iImpl);
	}

EXPORT_C TInt RSgImage::GetInfo(TSgImageInfo& aInfo) const
	{
	if (!iImpl)
		{
		return KErrBadHandle;
		}
	__ASSERT_ALWAYS(gPls.iDriver, Panic(ESgPanicNoDriver));
	__ASSERT_ALWAYS(gPls.iDriver->CheckImage(iImpl), Panic(ESgPanicBadDrawableHandle));
	static_cast<XSgImage*>(iImpl)->GetInfo(aInfo);
	return KErrNone;
	}

EXPORT_C TInt RSgImage::GetAttribute(TUid aUid, TInt& aValue) const
	{
	if (!iImpl)
		{
		return KErrBadHandle;
		}
	__ASSERT_ALWAYS(gPls.iDriver, Panic(ESgPanicNoDriver));
	__ASSERT_ALWAYS(gPls.iDriver->CheckImage(iImpl), Panic(ESgPanicBadDrawableHandle));
	return static_cast<XSgImage*>(iImpl)->GetAttribute(aUid, aValue);
	}

EXPORT_C TInt RSgImage::GetPixelFormats(TUint32 aUsage, RArray<TInt>& aPixelFormats, const TSgAttributeArrayBase* aAttributes)
	{
	static const TInt KSupportedPixelFormats[] =
		{
		ESgPixelFormatA_8,
		ESgPixelFormatRGB_565,
		ESgPixelFormatXRGB_8888,
		ESgPixelFormatARGB_8888,
		ESgPixelFormatARGB_8888_PRE
		};
	static const TInt KNumSupportedPixelFormats = sizeof(KSupportedPixelFormats) / sizeof(TInt);
	if (aUsage == 0 || aPixelFormats.Count() != 0)
		{
		return KErrArgument;
		}
	if (aAttributes)
		{
		return KErrNotSupported;
		}
	if (aUsage & ~KSgUsageAll)
		{
		return KErrNone;
		}
	_LIT(KLibOpenVg, "libOpenVG.dll");
	_LIT(KLibOpenGles, "libGLESv1_CM.dll");
	_LIT(KLibOpenGles2, "libGLESv2.dll");
	RLibrary lib;
	if (aUsage & (ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface))
		{
		if (lib.Load(KLibOpenVg) != KErrNone)
			{
			return KErrNone;
			}
		lib.Close();
		}
	if (aUsage & (ESgUsageBitOpenGlesTexture2D | ESgUsageBitOpenGlesSurface))
		{
		if (lib.Load(KLibOpenGles) != KErrNone)
			{
			return KErrNone;
			}
		lib.Close();
		}
	if (aUsage & (ESgUsageBitOpenGles2Texture2D | ESgUsageBitOpenGles2Surface))
		{
		if (lib.Load(KLibOpenGles2) != KErrNone)
			{
			return KErrNone;
			}
		lib.Close();
		}
	TInt err = KErrNone;
	for (TInt i = 0; i < KNumSupportedPixelFormats; ++i)
		{
		if (KSupportedPixelFormats[i] == ESgPixelFormatA_8 && (aUsage & KSgUsageAllSurfaceTypes))
			{
			continue;
			}
		err = aPixelFormats.Append(KSupportedPixelFormats[i]);
		if (err != KErrNone)
			{
			break;
			}
		}
	return err;
	}

XSgImage::XSgImage(TSgDrawableId aId, TUint32 aAttribs, const TSgImageMetaData& aMetaData, TAny* aDataAddress, TInt aDataStride)
	: iRefCount(1), iId(aId), iInfo(aMetaData.iSizeInPixels, aMetaData.iPixelFormat, aAttribs & KSgUsageBitMask),
	  iDataAddress(aDataAddress), iDataStride(aDataStride)
	{
	}

XSgImage::~XSgImage()
	{
	__ASSERT_DEBUG(iRefCount == 0, Panic(ESgPanicBadRefCount));
	}

TInt XSgImage::Open()
	{
	if (User::SafeInc(iRefCount) == 0)
		{
		return KErrNotFound;
		}
	return KErrNone;
	}

void XSgImage::Close()
	{
	if (User::SafeDec(iRefCount) == 1)
		{
		gPls.iDriver->DeleteImage(this);
		}
	}

TInt XSgImage::RefCount() const
	{
	return iRefCount;
	}

TSgDrawableId XSgImage::Id() const
	{
	return iId;
	}

TUid XSgImage::DrawableType() const
	{
	return KSgImageTypeUid;
	}

TInt XSgImage::GetInterface(TUid aInterfaceUid, TAny*& aInterfacePtr)
	{
	if (aInterfaceUid == KNullUid)
		{
		return KErrArgument;
		}
	if (aInterfaceUid.iUid == MSgImage_Sw::EInterfaceUid)
		{
		aInterfacePtr = static_cast<MSgImage_Sw*>(this);
		return KErrNone;
		}
	return KErrExtensionNotSupported;
	}

void XSgImage::GetInfo(TSgImageInfo& aInfo) const
	{
	aInfo = iInfo;
	}

TInt XSgImage::GetAttribute(TUid aUid, TInt& /*aValue*/) const
	{
	if (aUid == KNullUid)
		{
		return KErrArgument;
		}
	return KErrNotSupported;
	}

TInt XSgImage::Compare(const XSgImage& aImage1, const XSgImage& aImage2)
	{
	return Compare(&aImage1.iId, aImage2);
	}

TInt XSgImage::Compare(const TSgDrawableId* aId, const XSgImage& aImage)
	{
	if (aId->iId > aImage.iId.iId)
		{
		return 1;
		}
	if (aId->iId < aImage.iId.iId)
		{
		return -1;
		}
	return 0;
	}

TAny* XSgImage::DataAddress() const
	{
	return iDataAddress;
	}

TInt XSgImage::DataStride() const
	{
	return iDataStride;
	}