diff -r 000000000000 -r 5d03bc08d59c graphicsresourceservices/graphicsresource/src/sgimage.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicsresourceservices/graphicsresource/src/sgimage.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,476 @@ +// 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(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(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(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(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(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(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; + }