diff -r 000000000000 -r bde4ae8d615e os/graphics/graphicsresourceservices/graphicsresourceadaptation/inc/sgdriverimpl.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/graphicsresourceservices/graphicsresourceadaptation/inc/sgdriverimpl.h Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,313 @@ +// 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: +// + +/** + @file + @internalComponent +*/ + +#ifndef SGDRIVERIMPL_H +#define SGDRIVERIMPL_H + +#include "sgresourceadapter.h" +#include + + +/** +@internalComponent + +The category name of the panics raised by Graphics Resource Adapter. +*/ +_LIT(KSgResourceAdapterPanicCategory, "SGRES-ADAPTER"); + + +/** +The reason numbers of the panics raised by Graphics Resource Adapter. +*/ +enum TSgResourceAdapterPanicReason + { + /** + @internalComponent + + SGRES-ADAPTER 1 In debug builds, an instance of TSgImageInfo is invalid. + */ + ESgPanicBadImageInfo = 1, + /** + @internalComponent + + SGRES-ADAPTER 2 In debug builds, the reference count of an object is invalid. + */ + ESgPanicBadReferenceCount = 2, + /** + @internalComponent + + SGRES-ADAPTER 3 In debug builds, an internal function in the Graphics Resource + driver has been called without proper inter-thread synchronisation. + */ + ESgPanicMutexNotHeld = 3, + /** + @internalTechnology + @prototype + + SGRES-ADAPTER 4 In debug builds, an image has not been prepared for CPU access + to its pixel data. + */ + ESgPanicNoCpuAccess = 4, + /** + @internalComponent + + SGRES-ADAPTER 5 In debug builds, an internal function has failed unexpectedly. + */ + ESgPanicResourceAdapterGeneral = 5 + }; + + +/** +@internalComponent + +Panics the current thread specifying a panic reason from Graphics Resource Adapter. +*/ +inline void Panic(TSgResourceAdapterPanicReason aReason); + + +/** +@internalComponent + +Calculates the minimum number of bytes between rows of pixel data for a given +pixel width and pixel format, regardless of alignment. +*/ +TInt SgMinDataStride(TInt aWidth, TUidPixelFormat aPixelFormat); + + +/** +@internalComponent + +Calculates the number of bytes between rows of pixel data given the width in +pixels and the pixel format, taking into consideration the alignment +requirements of the hardware platform. +*/ +TInt SgAlignedDataStride(TInt aWidthInPixels, TUidPixelFormat aPixelFormat); + + +/** +@internalComponent + +Calculates the offset in bytes from the base of the underlying memory chunk to +the first buffer of a surface used to store images. +*/ +TInt SgOffsetToFirstBuffer(TInt aMetaDataSize); + + +/** +@internalComponent + +Calculates the size in bytes of a buffer able to store an image with the given +row size in bytes and number of rows. +*/ +TInt SgOffsetBetweenBuffers(TInt aDataStride, TInt aScanLineCount); + + +/** +@internalComponent + +Tests whether an instance of TSgImageInfo is valid. +*/ +TBool SgIsValidImageInfo(const TSgImageInfo& aInfo); + + +/** +@internalComponent + +Tests whether an instance of TSgImageInfo specifies mutable images. +*/ +TBool SgIsMutableImage(const TSgImageInfo& aInfo); + + +/** +@internalComponent + +Tests whether an instance of TSgImageInfo specifies CPU-cached images. +*/ +TBool SgIsCachedImage(const TSgImageInfo& aInfo); + + +class XSgDriverImpl; + +/** +@internalComponent + +Base class for all reference-counted classes to be instantiated on the heap for +adapter objects. Instances of derived classes must be allocated on the heap first +and then initialised using the placement new operator. + +This class provides: + - Initialisation of instances of derived classes to binary zeroes through a + specialised placement new operator. + - A virtual destructor and a Delete() function that allow instances of derived + classes to be properly destroyed and deallocated through a pointer to this class. + - A reference count. +*/ +class XSgBase + { +public: + virtual ~XSgBase(); + void Delete(); + inline void IncRefCount(); + inline TInt DecRefCount(); + inline TInt RefCount() const; + inline TAny* operator new(TUint aSize, TAny* aBase); +protected: + inline XSgBase(XSgDriverImpl& aDriverImpl); +private: + XSgBase(const XSgBase&); + const XSgBase& operator =(const XSgBase&); + TAny* operator new(TUint); +protected: + XSgDriverImpl& iDriverImpl; +private: + TInt iRefCount; + }; + + +/** +@internalComponent + +An entry in the pixel format support table. +*/ +class TSgPixelFormatTableEntry + { +public: + TBool IsMatch(const TSgImageInfo& aInfo) const; + TBool IsMatchIgnoringPixelFormat(const TSgImageInfo& aInfo) const; + TBool IsMatchIgnoringUsage(const TSgImageInfo& aInfo) const; +public: + /** + The supported pixel format. + */ + TUidPixelFormat iPixelFormat; + /** + The supported usages. + */ + TUint32 iUsage; + /** + The supported CPU access. + */ + TSgCpuAccess iCpuAccess; + /** + The supported screens. A value of -1 is interpreted as meaning that all screens + are supported. Zero and positive values are interpreted as meaning that only + the specified screen is supported. + */ + TInt iScreenId; + }; + + +class XSgImageImplBase; +class XSgImageCollectionImpl; + +/** +@internalComponent + +The Graphics Resource Adapter singleton class. The initialisation of the Graphics +Resource Adapter singleton consists of the following steps: + - The heap for adapter objects is created. + - An instance of the singleton class is allocated on the heap for adapter objects. + - The C++ constructor is called using the placement new operator and ownership + of the heap for adapter objects is transferred to the singleton. + - The second-phase constructor is called to complete construction of the singleton. + +This class owns a single mutex and provides Wait() and Signal() functions to synchronise +access to all the adapter objects. An alternative could be for each adapter object to +have an associated mutex, but the possible improvement in concurrency does not justify +the costs in systems with only one CPU. +*/ +class XSgDriverImpl: public MSgDriverAdapter + { +public: + inline XSgDriverImpl(RHeap* aHeap); + TInt Construct(); + ~XSgDriverImpl(); + inline TAny* operator new(TUint aSize, TAny* aBase); + inline void Wait(); + inline void Signal(); + inline TBool IsMutexHeld() const; + inline TAny* Alloc(TInt aSize); + inline void Free(TAny* aCell); + inline TInt CreateSurface(const RSurfaceManager::TSurfaceCreationAttributesBuf& aReqs, TSurfaceId& aSurfaceId); + inline TInt CreateSurface(const RSurfaceManager::TSurfaceCreationAttributesBuf& aReqs, TSurfaceId& aSurfaceId, const RChunk& aChunk); + inline TInt OpenSurface(const TSurfaceId& aSurfaceId); + inline TInt CloseSurface(const TSurfaceId& aSurfaceId); + TInt MapSurface(const TSurfaceId& aSurfaceId, RChunk& aChunk); + inline TInt SurfaceInfo(const TSurfaceId& aSurfaceId, RSurfaceManager::TInfoBuf& aInfo); + inline TInt SynchronizeCache(const TSurfaceId& aSurfaceId, TInt aBuffer, RSurfaceManager::TSyncOperation aOperation); + inline TInt GetSurfaceHint(const TSurfaceId& aSurfaceId, RSurfaceManager::THintPair& aHint); + TArray PixelFormatTable() const; + TInt CanCreateImage(const TSgImageInfo& aInfo) const; + TInt OpenImage(const TSgDrawableId& aId, TUint32 aMode, MSgDrawableAdapter*& aResult); + void DeleteImage(XSgImageImplBase* aImage); + void DeleteImageCollection(XSgImageCollectionImpl* aImageCollection); + // From MSgDriverAdapter + void Delete(); + TInt GetPixelFormats(const TSgImageInfo& aInfo, TUidPixelFormat* aPixelFormats, TInt& aCount); + TInt CreateImage(const TSgImageInfo& aInfo, const TAny* aDataAddress, TInt aDataStride, MSgDrawableAdapter*& aResult); + TInt CreateImage(const TSgImageInfo& aInfo, MSgImageAdapter* aImage, MSgDrawableAdapter*& aResult); + TInt CreateImageCollection(const TSgImageInfo& aInfo, TInt aImageCount, MSgImageCollectionAdapter*& aResult); + TInt CreateImageCollections(const TSgImageInfo aInfos[], TInt aImageCount, + MSgImageCollectionAdapter* aCollections[], TInt aCollectionCount); + TInt OpenDrawable(const TSgDrawableId& aId, TUint32 aMode, TUid aHandleType, MSgDrawableAdapter*& aResult); + TBool CheckDrawable(const MSgResourceAdapter& aDrawable) const; + TBool CheckImage(const MSgResourceAdapter& aImage) const; + TBool CheckImageCollection(const MSgResourceAdapter& aImageCollection) const; + TInt ResourceCount() const; + void AllocMarkStart(); + void AllocMarkEnd(TInt aCount); + void SetAllocFail(RAllocator::TAllocFail aType, TInt aRate); + TInt GetBufferOffset(const TSurfaceId& aSurfaceID, TInt aBuffer, TInt &aOffset); + TInt GetSurfaceManagerAttrib(RSurfaceManager::TSurfaceManagerAttrib aAttrib, TInt& aValue); +private: + XSgDriverImpl(const XSgDriverImpl&); + TInt ConstructPixelFormatTable(); + const XSgDriverImpl& operator =(const XSgDriverImpl&); + TAny* operator new(TUint); +private: + /** Handle to the mutex used to synchronize access to the adapter objects. */ + mutable RMutex iMutex; + /** Heap on which the adapter objects are allocated. */ + RHeap* iHeap; + /** Handle to the surface manager. */ + RSurfaceManager iSurfaceManager; + /** Pixel format support table. */ + RArray iPixelFormatTable; + /** Image adapter objects ordered by identifier. */ + RPointerArray iImages; + /** Image collection adapter objects ordered by address. */ + RPointerArray iImageCollections; + /** Size in pixels passed in the last call to GetPixelFormats(). */ + TSize iLastSizeInPixels; + /** Usage passed in the last call to GetPixelFormats(). */ + TUint32 iLastUsage; + /** CPU access passed in the last call to GetPixelFormats(). */ + TSgCpuAccess iLastCpuAccess; + /** Screen identifier passed in the last call to GetPixelFormats(). */ + TInt iLastScreenId; + /** Results of the last call to GetPixelFormats(). */ + RArray iLastPixelFormats; + }; + + +#include "sgdriverimpl.inl" + + +#endif // SGDRIVERIMPL_H