// 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:

//

#include "sgdriver.h"

#include "sgimageadapter.h"

/**

@publishedPartner

@prototype

@deprecated

Default constructor.

@pre None.

@post All the data members of this instance of TSgImageInfo are zero, false or null.

*/

EXPORT_C TSgImageInfo::TSgImageInfo()

	{

	Mem::FillZ(this, sizeof(TSgImageInfo));

	}

/**

@publishedPartner

@prototype

@deprecated

Default constructor.

@pre None.

@post This RSgImage handle is null.

*/

EXPORT_C RSgImage::RSgImage()

	{

	iHandleType = KSgImageTypeUid;

	}

/**

@publishedPartner

@prototype

@deprecated

Creates an image with the specified attributes and, optionally, the specified

initial contents.

@param aInfo The attributes of the image to be created.

@param aDataAddress The base address of the pixel data used to populate the new image.

       If this value is null, the initial contents of the image are undefined.

       If aInfo specifies that the new image is constant, this value must not be null.

@param aDataStride The number of bytes between rows of the pixel data used to populate

       the new image.

@pre The Graphics Resource driver is initialised for use in the context of the

     calling process.

@pre This RSgImage handle is null.

@pre aInfo is supported.

@post This RSgImage handle references a newly created image with the specified

      attributes and initial contents. The initial reference count for the image

      is one.

@return KErrNone if successful.

@return KErrInUse if this RSgImage handle was not null.

@return KErrArgument if aInfo is invalid.

@return KErrNoInitializationData if aInfo requests a constant image and aDataAddress

        is null.

@return KErrTooBig if the size specified in aInfo is too large.

@return KErrNotSupported if aInfo is not supported.

@return KErrNoMemory if there is not enough system memory.

@return KErrNoSpecializedMemory if there is not enough specialised graphics memory.

@panic SGRES 5 in debug builds if the Graphics Resource driver is not initialised

       for use in the context of the calling process.

*/

EXPORT_C TInt RSgImage::Create(const TSgImageInfo& aInfo, const TAny* aDataAddress, TInt aDataStride)

	{

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

#endif

	TInt err = gPls.iDriver->CreateImage(aInfo, aDataAddress, aDataStride, iImpl);

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	return err;

	}

/**

@publishedPartner

@prototype

@deprecated

Creates an image with the specified attributes and initial contents copied from an

existing image. The size and the pixel format of the image to be created must be the

same as the size and the pixel format of the existing image.

@param aInfo The attributes of the image to be created.

@param aImage A handle to the existing image to be copied.

@pre The Graphics Resource driver is initialised for use in the context of the

     calling process.

@pre This RSgImage handle is null.

@pre aInfo is supported.

@pre aImage is a valid and not null handle.

@pre The size and the pixel format specified in aInfo must be the same as the size

     and the pixel format of aImage.

@post This RSgImage handle references a newly created image with the specified

      attributes and initial contents. The initial reference count for the image

      is one.

@return KErrNone if successful.

@return KErrInUse if this RSgImage handle was not null.

@return KErrArgument if aInfo is invalid or if aImage is a null handle.

@return KErrNotSupported if aInfo is not supported or if the size and the pixel format

        specified in aInfo are not the same as the size and the pixel format of aImage.

@return KErrNoMemory if there is not enough system memory.

@return KErrNoSpecializedMemory if there is not enough specialised graphics memory.

@panic SGRES 3 in debug builds if aImage is an invalid handle.

@panic SGRES 5 in debug builds if the Graphics Resource driver is not initialised

       for use in the context of the calling process.

*/

EXPORT_C TInt RSgImage::Create(const TSgImageInfo& aInfo, const RSgImage& aImage)

	{

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

#endif

	TInt err = gPls.iDriver->CreateImage(aInfo, static_cast<MSgImageAdapter*>(aImage.iImpl), iImpl);

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	return err;

	}

/**

@publishedPartner

@prototype

@deprecated

Retrieves the values of the attributes of an image. This function can also retrieve

the values of selected user-defined attributes attached to an image by passing in

the globally unique identifiers of the user-defined attributes to be retrieved.

@param aInfo On input, the globally unique identifiers of the user-defined attributes

       to be retrieved from the image, if any. On return, the values of the attributes

       of the image and the values of the selected user-defined attributes.

@pre The Graphics Resource driver is initialised for use in the context of the

     calling process.

@pre This RSgImage handle is valid and not null.

@pre If aInfo.iUserAttributes is not null then it points to an array of

     aInfo.iUserAttributeCount elements with globally unique identifiers

     corresponding to user-defined attributes attached to the image.

@post None.

@return KErrNone if successful.

@return KErrBadHandle if this RSgImage handle is null.

@return KErrNotFound if any of the user-defined attributes to be retrieved from the

        image cannot be found.

@panic SGRES 3 in debug builds if this RSgImage handle is invalid.

@panic SGRES 5 in debug builds if the Graphics Resource driver is not initialised

       for use in the context of the calling process.

@see TSgImageInfo

*/

EXPORT_C TInt RSgImage::GetInfo(TSgImageInfo& aInfo) const

	{

	if (!iImpl)

		{

		return KErrBadHandle;

		}

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

	__ASSERT_DEBUG(gPls.iDriver->CheckImage(*iImpl), Panic(ESgPanicBadImageHandle));

#endif

	TInt err = static_cast<MSgImageAdapter*>(iImpl)->GetInfo(aInfo);

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	return err;

	}

/**

@publishedPartner

@prototype

@deprecated

Temporarily makes the pixel data of an image accessible for reading by the CPU.

Undefined behaviour occurs if the CPU tries to modify the pixel data.

When finished with the pixel data, the caller must end the mapping by calling Unmap()

on this RSgImage handle.

If an image is shared across processes, only the creator process is allowed to map

the image for access to its pixel data.

Depending upon the hardware architecture, whilst an image is mapped the GPU may be

denied access to the pixel data, so this function may cause GPU operations that use

this image to fail if proper synchronisation is not provided by means of the

mechanisms available from the different rendering pipelines or from specialised

synchronisation objects. Likewise, if the GPU is using the image at the time this

function is called, the mapping may fail with KErrInUse. Note that even if operations

do not fail, the results are not guaranteed to be correct unless proper synchronisation

is provided.

@param aDataAddress On return, the base address of the pixel data in the address

       space of the calling process.

@param aDataStride On return, the number of bytes between rows of the pixel data.

@pre The Graphics Resource driver is initialised for use in the context of the

     calling process.

@pre This RSgImage handle is valid and not null.

@pre The image is not mapped yet.

@pre The image was created with CPU access ESgCpuAccessReadOnly or ESgCpuAccessReadWrite.

@pre The image was created by the calling process.

@post The pixel data of the image is directly accessible in the address space of the

      calling process for reading only, until Unmap() is called.

@return KErrNone if successful.

@return KErrBadHandle if this RSgImage handle is null.

@return KErrInUse if the image is already mapped or in exclusive use by the GPU.

@return KErrAccessDenied if the image was not created with CPU access ESgCpuAccessReadOnly

        or ESgCpuAccessReadWrite.

@return KErrPermissionDenied if the image was created by another process.

@return KErrNoMemory if there is not enough system memory.

@panic SGRES 3 in debug builds if this RSgImage handle is invalid.

@panic SGRES 5 in debug builds if the Graphics Resource driver is not initialised

       for use in the context of the calling process.

*/

EXPORT_C TInt RSgImage::MapReadOnly(const TAny*& aDataAddress, TInt& aDataStride) const

	{

	if (!iImpl)

		{

		return KErrBadHandle;

		}

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

	__ASSERT_DEBUG(gPls.iDriver->CheckImage(*iImpl), Panic(ESgPanicBadImageHandle));

#endif

	TInt err = static_cast<MSgImageAdapter*>(iImpl)->MapReadOnly(aDataAddress, aDataStride);

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	return err;

	}

/**

@publishedPartner

@prototype

@deprecated

Temporarily makes the pixel data of an image accessible for writing by the CPU.

Any pre-existing content is discarded, meaning that the mapped memory initially

contains undefined pixel data.

When finished with the pixel data, the caller must end the mapping by calling Unmap()

on this RSgImage handle. The caller is required to write to every pixel of the image

before unmapping.

If an image is shared across processes, only the creator process is allowed to map

the image for access to its pixel data.

Depending upon the hardware architecture, whilst an image is mapped the GPU may be

denied access to the pixel data, so this function may cause GPU operations that use

this image to fail if proper synchronisation is not provided by means of the

mechanisms available from the different rendering pipelines or from specialised

synchronisation objects. Likewise, if the GPU is using the image at the time this

function is called, the mapping may fail with KErrInUse. Note that even if operations

do not fail, the results are not guaranteed to be correct unless proper synchronisation

is provided.

@param aDataAddress On return, the base address of the pixel data in the address

       space of the calling process.

@param aDataStride On return, the number of bytes between rows of the pixel data.

@pre The Graphics Resource driver is initialised for use in the context of the

     calling process.

@pre This RSgImage handle is valid and not null.

@pre The image is not mapped yet.

@pre The image was created with CPU access ESgCpuAccessWriteOnly or ESgCpuAccessReadWrite.

@pre The image was created by the calling process.

@post The pixel data of the image is directly accessible in the address space of the

      calling process for writing only, until Unmap() is called.

@return KErrNone if successful.

@return KErrBadHandle if this RSgImage handle is null.

@return KErrInUse if the image is already mapped or in exclusive use by the GPU.

@return KErrAccessDenied if the image was not created with CPU access ESgCpuAccessWriteOnly

        or ESgCpuAccessReadWrite.

@return KErrPermissionDenied if the image was created by another process.

@return KErrNoMemory if there is not enough system memory.

@panic SGRES 3 in debug builds if this RSgImage handle is invalid.

@panic SGRES 5 in debug builds if the Graphics Resource driver is not initialised

       for use in the context of the calling process.

*/

EXPORT_C TInt RSgImage::MapWriteOnly(TAny*& aDataAddress, TInt& aDataStride)

	{

	if (!iImpl)

		{

		return KErrBadHandle;

		}

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

	__ASSERT_DEBUG(gPls.iDriver->CheckImage(*iImpl), Panic(ESgPanicBadImageHandle));

#endif

	TInt err = static_cast<MSgImageAdapter*>(iImpl)->MapWriteOnly(aDataAddress, aDataStride);

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	return err;

	}

/**

@publishedPartner

@prototype

@deprecated

Temporarily makes the pixel data of an image accessible for reading and writing

by the CPU.

When finished with the pixel data, the caller must end the mapping by calling Unmap()

on this RSgImage handle. Any modification performed by the CPU will be retained upon

unmapping.

If an image is shared across processes, only the creator process is allowed to map

the image for access to its pixel data.

Depending upon the hardware architecture, whilst an image is mapped the GPU may be

denied access to the pixel data, so this function may cause GPU operations that use

this image to fail if proper synchronisation is not provided by means of the

mechanisms available from the different rendering pipelines or from specialised

synchronisation objects. Likewise, if the GPU is using the image at the time this

function is called, the mapping may fail with KErrInUse. Note that even if operations

do not fail, the results are not guaranteed to be correct unless proper synchronisation

is provided.

@param aDataAddress On return, the base address of the pixel data in the address

       space of the calling process.

@param aDataStride On return, the number of bytes between rows of the pixel data.

@pre The Graphics Resource driver is initialised for use in the context of the

     calling process.

@pre This RSgImage handle is valid and not null.

@pre The image is not mapped yet.

@pre The image was created with CPU access ESgCpuAccessReadWrite.

@pre The image was created by the calling process.

@post The pixel data of the image is directly accessible in the address space of the

      calling process for reading and writing, until Unmap() is called.

@return KErrNone if successful.

@return KErrBadHandle if this RSgImage handle is null.

@return KErrInUse if the image is already mapped or in exclusive use by the GPU.

@return KErrAccessDenied if the image was not created with CPU access

        ESgCpuAccessReadWrite.

@return KErrPermissionDenied if the image was created by another process.

@return KErrNoMemory if there is not enough system memory.

@panic SGRES 3 in debug builds if this RSgImage handle is invalid.

@panic SGRES 5 in debug builds if the Graphics Resource driver is not initialised

       for use in the context of the calling process.

*/

EXPORT_C TInt RSgImage::MapReadWrite(TAny*& aDataAddress, TInt& aDataStride)

	{

	if (!iImpl)

		{

		return KErrBadHandle;

		}

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

	__ASSERT_DEBUG(gPls.iDriver->CheckImage(*iImpl), Panic(ESgPanicBadImageHandle));

#endif

	TInt err = static_cast<MSgImageAdapter*>(iImpl)->MapReadWrite(aDataAddress, aDataStride);

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	return err;

	}

/**

@publishedPartner

@prototype

@deprecated

Makes the pixel data of an image no longer accessible by the CPU. If the image was

mapped for writing by the CPU, any written data is retained and any subsequent usage

of the image by the GPU will reflect its new state.

If the last handle to an image in a process is closed while the image is still mapped

by the process then the image will be automatically unmapped.

@pre The Graphics Resource driver is initialised for use in the context of the

     calling process.

@pre This RSgImage handle is valid and not null.

@pre The image is mapped for CPU access by a previous call to MapReadOnly(),

     MapWriteOnly() or MapReadWrite().

@post The GPU is guaranteed to be able to get access to the image.

@post The address range in the calling process used for the mapping is no longer

      valid. Attempts by the calling process to access any address in this range

      will result in undefined behaviour.

@return KErrNone if successful.

@return KErrBadHandle if this RSgImage handle is null.

@return KErrGeneral if the image was not mapped for CPU access.

@panic SGRES 3 in debug builds if this RSgImage handle is invalid.

@panic SGRES 5 in debug builds if the Graphics Resource driver is not initialised

       for use in the context of the calling process.

*/

EXPORT_C TInt RSgImage::Unmap() const

	{

	if (!iImpl)

		{

		return KErrBadHandle;

		}

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

	__ASSERT_DEBUG(gPls.iDriver->CheckImage(*iImpl), Panic(ESgPanicBadImageHandle));

#endif

	TInt err = static_cast<MSgImageAdapter*>(iImpl)->Unmap();

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	return err;

	}

/**

@publishedPartner

@prototype

@deprecated

Retrieves the list of image pixel formats supported on this device for a specified

usage. This function is often called before creating images.

@param aInfo The image attributes. aInfo.iPixelFormat is ignored.

@param aPixelFormats A pointer to an array that on return will contain the supported

       pixel formats. If this parameter is null, then this function will just

       return the number of supported pixel formats in aCount.

@param aCount On input, the number of elements in the array pointed to by aPixelFormats

       if not null, ignored otherwise. On return, the actual number of supported pixel

       formats. If this number is greater than the number of elements in the array,

       then the array will be filled with as many pixel formats as it can hold and the

       function will return KErrOverflow.

@pre The Graphics Resource driver is initialised for use in the context of the

     calling process.

@pre aInfo is valid.

@pre If aPixelFormats is not null then aCount is greater than zero.

@post None.

@return KErrNone if successful.

@return KErrArgument if aInfo is invalid or if aPixelFormats is not null and aCount

        is negative.

@return KErrOverflow if the actual number of supported pixel formats is greater than

        the number of elements in the array pointed to by aPixelFormats.

@return KErrNoMemory if there is not enough system memory.

@panic SGRES 5 in debug builds if the Graphics Resource driver is not initialised

       for use in the context of the calling process.

*/

EXPORT_C TInt RSgImage::GetPixelFormats(const TSgImageInfo& aInfo, TUidPixelFormat* aPixelFormats, TInt& aCount)

	{

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

#endif

	TInt err = gPls.iDriver->GetPixelFormats(aInfo, aPixelFormats, aCount);

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	return err;

	}