1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "sgimageimpl.h"

    17 #include "sgresourceinternal.h"

    18 

    19 

    20 // TSgImageMetaData

    21 

    22 TSgImageMetaData::TSgImageMetaData(const TSgImageInfo& aInfo, TArray<TSgPixelFormatTableEntry> aPixelFormatTable, TBool aIsCached)

    23 	: iCreatorProcess(RProcess().Id()),

    24 	  iSizeInPixels(aInfo.iSizeInPixels),

    25 	  iPixelFormat(aInfo.iPixelFormat),

    26 	  iRequestedUsage(aInfo.iUsage),

    27 	  iPotentialUsage(0),

    28 	  iShareable(aInfo.iShareable),

    29 	  iCpuAccess(aInfo.iCpuAccess),

    30 	  iScreenId(aInfo.iScreenId),

    31 	  iIsCached(aIsCached)

    32 	{

    33 	TUint32 usageMask = (aInfo.iUsage & KSgUsageAllSources ? KSgUsageAllSources : 0)

    34 	                    | (aInfo.iUsage & KSgUsageAllTargets ? KSgUsageAllTargets : 0);

    35 	TInt n = aPixelFormatTable.Count();

    36 	for (TInt i = 0; i < n; ++i)

    37 		{

    38 		const TSgPixelFormatTableEntry& entry = aPixelFormatTable[i];

    39 		if (entry.IsMatchIgnoringUsage(aInfo))

    40 			{

    41 			iPotentialUsage |= entry.iUsage & usageMask;

    42 			}

    43 		}

    44 	}

    45 

    46 

    47 void TSgImageMetaData::GetInfo(TSgImageInfo& aInfo, TBool aGetPotentialUsage) const

    48 	{

    49 	aInfo.iSizeInPixels = iSizeInPixels;

    50 	aInfo.iPixelFormat = iPixelFormat;

    51 	aInfo.iUsage = aGetPotentialUsage ? iPotentialUsage : iRequestedUsage;

    52 	aInfo.iShareable = iShareable;

    53 	aInfo.iCpuAccess = iCpuAccess;

    54 	aInfo.iScreenId = iScreenId;

    55 	}

    56 

    57 

    58 // XSgImageImplBase

    59 

    60 XSgImageImplBase::XSgImageImplBase(const XSgImageImplBase& aImage, TUint32 aFlags)

    61 	: XSgBase(aImage.iDriverImpl)

    62 	{

    63 	__ASSERT_DEBUG(iDriverImpl.IsMutexHeld(), Panic(ESgPanicMutexNotHeld));

    64 	iId = aImage.iId;

    65 	iId.iId[KSgImageIdFlagsIndex] = aFlags;

    66 	aImage.iState->IncRefCount();

    67 	iState = aImage.iState;

    68 	}

    69 

    70 

    71 XSgImageImplBase::~XSgImageImplBase()

    72 	{

    73 	__ASSERT_DEBUG(iDriverImpl.IsMutexHeld(), Panic(ESgPanicMutexNotHeld));

    74 	if (iState && iState->DecRefCount() == 0)

    75 		{

    76 		Unmap();

    77 		iState->Delete();

    78 		}

    79 	}

    80 

    81 

    82 TInt XSgImageImplBase::Compare(const TSgDrawableId* aId, const XSgImageImplBase& aImage)

    83 	{

    84 	return Mem::Compare(reinterpret_cast<const TUint8*>(aId), sizeof(TSgDrawableId),

    85 	                    reinterpret_cast<const TUint8*>(&aImage.Id()), sizeof(TSgDrawableId));

    86 	}

    87 

    88 

    89 TInt XSgImageImplBase::Compare(const XSgImageImplBase& aImage1, const XSgImageImplBase& aImage2)

    90 	{

    91 	return Compare(&aImage1.Id(), aImage2);

    92 	}

    93 

    94 

    95 TInt XSgImageImplBase::CompareIgnoringFlags(const TSgDrawableId* aId, const XSgImageImplBase& aImage)

    96 	{

    97 	return Mem::Compare(reinterpret_cast<const TUint8*>(aId), sizeof(TSgDrawableId) - sizeof(TUint32),

    98 	                    reinterpret_cast<const TUint8*>(&aImage.Id()), sizeof(TSgDrawableId) - sizeof(TUint32));

    99 	}

   100 

   101 

   102 void XSgImageImplBase::Close()

   103 	{

   104 	XSgDriverImpl& driverImpl = iDriverImpl;

   105 	driverImpl.Wait();

   106 	if (DecRefCount() == 0)

   107 		{

   108 		driverImpl.DeleteImage(this);

   109 		}

   110 	driverImpl.Signal();

   111 	}

   112 

   113 

   114 const TSgDrawableId& XSgImageImplBase::Id() const

   115 	{

   116 	return iId;

   117 	}

   118 

   119 

   120 TUid XSgImageImplBase::DrawableType() const

   121 	{

   122 	return KSgImageTypeUid;

   123 	}

   124 

   125 

   126 TInt XSgImageImplBase::GetInterface(TUid aInterfaceUid, TAny*& aInterfacePtr)

   127 	{

   128 	if (aInterfaceUid.iUid == MSgImage_Sw::EInterfaceUid)

   129 		{

   130 		aInterfacePtr = static_cast<MSgImage_Sw*>(this);

   131 		return KErrNone;

   132 		}

   133 	return KErrExtensionNotSupported;

   134 	}

   135 

   136 

   137 TInt XSgImageImplBase::GetInfo(TSgImageInfo& aInfo) const

   138 	{

   139 	iState->MetaData().GetInfo(aInfo, iId.iId[KSgImageIdFlagsIndex] & ESgDoNotRestrictUsage);

   140 	return iState->GetUserAttributes(aInfo.iUserAttributes, aInfo.iUserAttributeCount);

   141 	}

   142 

   143 

   144 TInt XSgImageImplBase::MapReadOnly(const TAny*& aDataAddress, TInt& aDataStride)

   145 	{

   146 	TInt err = iState->BeginDataAccess(ESgCpuAccessReadOnly, ETrue);

   147 	if (err != KErrNone)

   148 		{

   149 		return err;

   150 		}

   151 	aDataAddress = iState->DataAddress();

   152 	aDataStride = iState->DataStride();

   153 	return KErrNone;

   154 	}

   155 

   156 

   157 TInt XSgImageImplBase::MapWriteOnly(TAny*& aDataAddress, TInt& aDataStride)

   158 	{

   159 	TInt err = iState->BeginDataAccess(ESgCpuAccessWriteOnly, ETrue);

   160 	if (err != KErrNone)

   161 		{

   162 		return err;

   163 		}

   164 	aDataAddress = iState->DataAddress();

   165 	aDataStride = iState->DataStride();

   166 	return KErrNone;

   167 	}

   168 

   169 

   170 TInt XSgImageImplBase::MapReadWrite(TAny*& aDataAddress, TInt& aDataStride)

   171 	{

   172 	TInt err = iState->BeginDataAccess(ESgCpuAccessReadWrite, ETrue);

   173 	if (err != KErrNone)

   174 		{

   175 		return err;

   176 		}

   177 	aDataAddress = iState->DataAddress();

   178 	aDataStride = iState->DataStride();

   179 	return KErrNone;

   180 	}

   181 

   182 

   183 TInt XSgImageImplBase::Unmap()

   184 	{

   185 	return iState->EndDataAccess(ETrue);

   186 	}

   187 

   188 

   189 TAny* XSgImageImplBase::DataAddress() const

   190 	{

   191 	return iState->DataAddress();

   192 	}

   193 

   194 

   195 TInt XSgImageImplBase::DataStride() const

   196 	{

   197 	return iState->DataStride();

   198 	}

   199 

   200 

   201 TInt XSgImageImplBase::BeginDataAccess(TSgCpuAccess aCpuAccess)

   202 	{

   203 	return iState->BeginDataAccess(aCpuAccess, EFalse);

   204 	}

   205 

   206 

   207 TInt XSgImageImplBase::EndDataAccess()

   208 	{

   209 	return iState->EndDataAccess(EFalse);

   210 	}

   211 

   212 

   213 TInt XSgImageImplBase::SetData(const TAny* aDataAddress, TInt aDataStride)

   214 	{

   215 	if (aDataAddress)

   216 		{

   217 		TInt err = BeginDataAccess(ESgCpuAccessWriteOnly);

   218 		if (err != KErrNone)

   219 			{

   220 			return err;

   221 			}

   222 		const TSgImageMetaData& metaData = iState->MetaData();

   223 		const TAny* src = aDataAddress;

   224 		TAny* trg = iState->DataAddress();

   225 		TInt dataStride = iState->DataStride();

   226 		TInt minDataStride = SgMinDataStride(metaData.iSizeInPixels.iWidth, metaData.iPixelFormat);

   227 		__ASSERT_DEBUG(minDataStride > 0, Panic(ESgPanicResourceAdapterGeneral));

   228 		for (TInt y = 0; y < metaData.iSizeInPixels.iHeight; ++y)

   229 			{

   230 			Mem::Copy(trg, src, minDataStride);

   231 			src = PtrAdd(src, aDataStride);

   232 			trg = PtrAdd(trg, dataStride);

   233 			}

   234 		EndDataAccess();

   235 		}

   236 	return KErrNone;

   237 	}

   238 

   239 

   240 TInt XSgImageStateBase::BeginDataAccess(TSgCpuAccess aCpuAccess, TBool aIsUserAccess)

   241 	{

   242 	if (aCpuAccess == ESgCpuAccessNone)

   243 		{

   244 		return KErrArgument;

   245 		}

   246 	const TSgImageMetaData& metaData = MetaData();

   247 	if (aIsUserAccess && (~metaData.iCpuAccess & aCpuAccess))

   248 		{

   249 		return KErrAccessDenied;

   250 		}

   251 	if (aIsUserAccess && metaData.iCreatorProcess != RProcess().Id())

   252 		{

   253 		return KErrPermissionDenied;

   254 		}

   255 	iDriverImpl.Wait();

   256 	if (iCpuAccess != ESgCpuAccessNone)

   257 		{

   258 		iDriverImpl.Signal();

   259 		return KErrInUse;

   260 		}

   261 	iCpuAccess = aCpuAccess;

   262 	iIsUserAccess = aIsUserAccess;

   263 	iDriverImpl.Signal();

   264 	return KErrNone;

   265 	}

   266 

   267 

   268 TInt XSgImageStateBase::EndDataAccess(TBool aIsUserAccess)

   269 	{

   270 	iDriverImpl.Wait();

   271 	if (iCpuAccess == ESgCpuAccessNone || iIsUserAccess != aIsUserAccess)

   272 		{

   273 		iDriverImpl.Signal();

   274 		return KErrGeneral;

   275 		}

   276 	iCpuAccess = ESgCpuAccessNone;

   277 	iIsUserAccess = EFalse;

   278 	iDriverImpl.Signal();

   279 	return KErrNone;

   280 	}

   281 

   282 

   283 #ifndef SYMBIAN_GRAPHICS_USE_GPU

   284 

   285 // XSgImageImpl_SwLocal

   286 

   287 TInt XSgImageImpl_SwLocal::New(XSgImageImpl_SwLocal*& aPtr, XSgDriverImpl& aDriverImpl, const TSgDrawableId& aId,

   288 	                           const TSgImageInfo& aInfo, const TAny* aDataAddress, TInt aDataStride)

   289 	{

   290 	aPtr = static_cast<XSgImageImpl_SwLocal*>(aDriverImpl.Alloc(sizeof(XSgImageImpl_SwLocal)));

   291 	if (!aPtr)

   292 		{

   293 		return KErrNoMemory;

   294 		}

   295 	new(aPtr) XSgImageImpl_SwLocal(aDriverImpl, aId);

   296 	TInt err = aPtr->Construct(aInfo, aDataAddress, aDataStride);

   297 	if (err != KErrNone)

   298 		{

   299 		aPtr->Delete();

   300 		aPtr = NULL;

   301 		}

   302 	return err;

   303 	}

   304 

   305 

   306 TInt XSgImageImpl_SwLocal::New(XSgImageImpl_SwLocal*& aPtr, const XSgImageImpl_SwLocal& aImage, TUint32 aFlags)

   307 	{

   308 	aPtr = static_cast<XSgImageImpl_SwLocal*>(aImage.iDriverImpl.Alloc(sizeof(XSgImageImpl_SwLocal)));

   309 	if (!aPtr)

   310 		{

   311 		return KErrNoMemory;

   312 		}

   313 	new(aPtr) XSgImageImpl_SwLocal(aImage, aFlags);

   314 	return KErrNone;

   315 	}

   316 

   317 

   318 TInt XSgImageImpl_SwLocal::Construct(const TSgImageInfo& aInfo, const TAny* aDataAddress, TInt aDataStride)

   319 	{

   320 	XSgImageState_SwLocal* state;

   321 	TInt err = XSgImageState_SwLocal::New(state, iDriverImpl, aInfo);

   322 	if (err != KErrNone)

   323 		{

   324 		return err;

   325 		}

   326 	state->IncRefCount();

   327 	iState = state;

   328 	return SetData(aDataAddress, aDataStride);

   329 	}

   330 

   331 

   332 // XSgImageState_SwLocal

   333 

   334 TInt XSgImageState_SwLocal::New(XSgImageState_SwLocal*& aPtr, XSgDriverImpl& aDriverImpl, const TSgImageInfo& aInfo)

   335 	{

   336 	TInt dataStride = Align4(SgMinDataStride(aInfo.iSizeInPixels.iWidth, aInfo.iPixelFormat));

   337 	TInt size = _FOFF(XSgImageState_SwLocal, iUserAttributes) + aInfo.iUserAttributeCount * sizeof(TSgUserAttribute) + dataStride * aInfo.iSizeInPixels.iHeight;

   338 	aPtr = static_cast<XSgImageState_SwLocal*>(aDriverImpl.Alloc(size));

   339 	if (!aPtr)

   340 		{

   341 		return KErrNoMemory;

   342 		}

   343 	new(aPtr) XSgImageState_SwLocal(aDriverImpl, aInfo, dataStride);

   344 	return KErrNone;

   345 	}

   346 

   347 

   348 XSgImageState_SwLocal::XSgImageState_SwLocal(XSgDriverImpl& aDriverImpl, const TSgImageInfo& aInfo, TInt aDataStride)

   349 	: XSgImageStateBase(aDriverImpl, aDataStride), iMetaData(aInfo, aDriverImpl.PixelFormatTable())

   350 	{

   351 	iUserAttributeCount = aInfo.iUserAttributeCount;

   352 	Mem::Copy(iUserAttributes, aInfo.iUserAttributes, aInfo.iUserAttributeCount * sizeof(TSgUserAttribute));

   353 	}

   354 

   355 

   356 const TSgImageMetaData& XSgImageState_SwLocal::MetaData() const

   357 	{

   358 	return iMetaData;

   359 	}

   360 

   361 

   362 TInt XSgImageState_SwLocal::GetUserAttributes(TSgUserAttribute* aUserAttributes, TInt aUserAttributeCount) const

   363 	{

   364 	for (TInt i = 0; i < aUserAttributeCount; ++i)

   365 		{

   366 		TBool found = EFalse;

   367 		for (TInt j = 0; j < iUserAttributeCount; ++j)

   368 			{

   369 			if (aUserAttributes[i].iUid == iUserAttributes[j].iUid)

   370 				{

   371 				aUserAttributes[i].iValue = iUserAttributes[j].iValue;

   372 				found = ETrue;

   373 				break;

   374 				}

   375 			}

   376 		if (!found)

   377 			{

   378 			return KErrNotFound;

   379 			}

   380 		}

   381 	return KErrNone;

   382 	}

   383 

   384 

   385 TAny* XSgImageState_SwLocal::DataAddress() const

   386 	{

   387 	//__ASSERT_DEBUG(iCpuAccess != ESgCpuAccessNone, ::Panic(ESgPanicNoCpuAccess));

   388 	return (TAny*)PtrAdd(iUserAttributes, iUserAttributeCount * sizeof(TSgUserAttribute));

   389 	}

   390 

   391 #endif

   392 

   393 

   394 // XSgImageImpl_SurfaceManager

   395 

   396 

   397 TInt XSgImageImpl_SurfaceManager::New(XSgImageImpl_SurfaceManager*& aPtr, XSgDriverImpl& aDriverImpl,

   398                                       const TSgImageInfo& aInfo, TBool aIsCached, const TAny* aDataAddress, TInt aDataStride)

   399 	{

   400 	aPtr = static_cast<XSgImageImpl_SurfaceManager*>(aDriverImpl.Alloc(sizeof(XSgImageImpl_SurfaceManager)));

   401 	if (!aPtr)

   402 		{

   403 		return KErrNoMemory;

   404 		}

   405 	new(aPtr) XSgImageImpl_SurfaceManager(aDriverImpl);

   406 	TInt err = aPtr->Construct(aInfo, aIsCached, aDataAddress, aDataStride);

   407 	if (err != KErrNone)

   408 		{

   409 		aPtr->Delete();

   410 		aPtr = NULL;

   411 		}

   412 	return err;

   413 	}

   414 

   415 

   416 TInt XSgImageImpl_SurfaceManager::New(XSgImageImpl_SurfaceManager*& aPtr, XSgDriverImpl& aDriverImpl, const TSgDrawableId& aId)

   417 	{

   418 	aPtr = static_cast<XSgImageImpl_SurfaceManager*>(aDriverImpl.Alloc(sizeof(XSgImageImpl_SurfaceManager)));

   419 	if (!aPtr)

   420 		{

   421 		return KErrNoMemory;

   422 		}

   423 	new(aPtr) XSgImageImpl_SurfaceManager(aDriverImpl, aId);

   424 	TInt err = aPtr->Construct(aId);

   425 	if (err != KErrNone)

   426 		{

   427 		aPtr->Delete();

   428 		aPtr = NULL;

   429 		}

   430 	return err;

   431 	}

   432 

   433 

   434 TInt XSgImageImpl_SurfaceManager::New(XSgImageImpl_SurfaceManager*& aPtr, const XSgImageImpl_SurfaceManager& aImage, TUint32 aFlags)

   435 	{

   436 	aPtr = static_cast<XSgImageImpl_SurfaceManager*>(aImage.iDriverImpl.Alloc(sizeof(XSgImageImpl_SurfaceManager)));

   437 	if (!aPtr)

   438 		{

   439 		return KErrNoMemory;

   440 		}

   441 	new(aPtr) XSgImageImpl_SurfaceManager(aImage, aFlags);

   442 	return KErrNone;

   443 	}

   444 

   445 

   446 TInt XSgImageImpl_SurfaceManager::Construct(const TSgImageInfo& aInfo, TBool aIsCached, const TAny* aDataAddress, TInt aDataStride)

   447 	{

   448 	XSgImageState_SurfaceManager* state;

   449 	TInt err = XSgImageState_SurfaceManager::New(state, iDriverImpl, aInfo, aIsCached);

   450 	if (err != KErrNone)

   451 		{

   452 		return err;

   453 		}

   454 	Mem::Copy(&iId, &state->SurfaceId(), sizeof(TSurfaceId));

   455 	state->IncRefCount();

   456 	iState = state;

   457 	return SetData(aDataAddress, aDataStride);

   458 	}

   459 

   460 

   461 TInt XSgImageImpl_SurfaceManager::Construct(const TSgDrawableId& aId)

   462 	{

   463 	XSgImageState_SurfaceManager* state;

   464 	TInt err = XSgImageState_SurfaceManager::New(state, iDriverImpl, aId);

   465 	if (err != KErrNone)

   466 		{

   467 		return err;

   468 		}

   469 	state->IncRefCount();

   470 	iState = state;

   471 	return KErrNone;

   472 	}

   473 

   474 

   475 TInt XSgImageImpl_SurfaceManager::GetInterface(TUid aInterfaceUid, TAny*& aInterfacePtr)

   476 	{

   477 	if (aInterfaceUid.iUid == MSgImage_Chunk::EInterfaceUid)

   478 		{

   479 		aInterfacePtr = static_cast<MSgImage_Chunk*>(this);

   480 		return KErrNone;

   481 		}

   482 	return XSgImageImplBase::GetInterface(aInterfaceUid, aInterfacePtr);

   483 	}

   484 

   485 

   486 const RChunk& XSgImageImpl_SurfaceManager::DataChunk() const

   487 	{

   488 	return static_cast<XSgImageState_SurfaceManager*>(iState)->DataChunk();

   489 	}

   490 

   491 

   492 TInt XSgImageImpl_SurfaceManager::DataOffset() const

   493 	{

   494 	return static_cast<XSgImageState_SurfaceManager*>(iState)->DataOffset();

   495 	}

   496 

   497 

   498 TInt XSgImageImpl_SurfaceManager::DataStride() const

   499 	{

   500 	return iState->DataStride();

   501 	}

   502 

   503 

   504 // XSgImageState_SurfaceManager

   505 

   506 TInt XSgImageState_SurfaceManager::New(XSgImageState_SurfaceManager*& aPtr, XSgDriverImpl& aDriverImpl, const TSgImageInfo& aInfo, TBool aIsCached)

   507 	{

   508 	aPtr = static_cast<XSgImageState_SurfaceManager*>(aDriverImpl.Alloc(sizeof(XSgImageState_SurfaceManager)));

   509 	if (!aPtr)

   510 		{

   511 		return KErrNoMemory;

   512 		}

   513 	new(aPtr) XSgImageState_SurfaceManager(aDriverImpl);

   514 	TInt err = aPtr->Construct(aInfo, aIsCached);

   515 	if (err != KErrNone)

   516 		{

   517 		aPtr->Delete();

   518 		aPtr = NULL;

   519 		}

   520 	return err;

   521 	}

   522 

   523 

   524 TInt XSgImageState_SurfaceManager::New(XSgImageState_SurfaceManager*& aPtr, XSgDriverImpl& aDriverImpl, const TSgDrawableId& aId)

   525 	{

   526 	aPtr = static_cast<XSgImageState_SurfaceManager*>(aDriverImpl.Alloc(sizeof(XSgImageState_SurfaceManager)));

   527 	if (!aPtr)

   528 		{

   529 		return KErrNoMemory;

   530 		}

   531 	new(aPtr) XSgImageState_SurfaceManager(aDriverImpl);

   532 	TInt err = aPtr->Construct(aId);

   533 	if (err != KErrNone)

   534 		{

   535 		aPtr->Delete();

   536 		aPtr = NULL;

   537 		}

   538 	return err;

   539 	}

   540 

   541 

   542 TInt XSgImageState_SurfaceManager::Construct(const TSgImageInfo& aInfo, TBool aIsCached)

   543 	{

   544 	TInt maxNumberOfHints;

   545 	TInt err;

   546 	err=iDriverImpl.GetSurfaceManagerAttrib(RSurfaceManager::EMaxNumberOfHints,maxNumberOfHints);

   547 	if (err!=KErrNone)

   548 		{

   549 		return err;

   550 		}

   551 	

   552 	if (aInfo.iUserAttributeCount > maxNumberOfHints)

   553 		{

   554 		return KErrOverflow;

   555 		}

   556 	RSurfaceManager::THintPair* hints = new RSurfaceManager::THintPair[aInfo.iUserAttributeCount];

   557 	if(!hints)

   558 		{

   559 		return KErrNoMemory;

   560 		}

   561 	RSurfaceManager::TSurfaceCreationAttributesBuf reqs;

   562 	reqs().iSurfaceHints = hints;

   563 	reqs().iHintCount = aInfo.iUserAttributeCount;

   564 	reqs().iSize = aInfo.iSizeInPixels;

   565 	reqs().iBuffers = 1;

   566 	reqs().iPixelFormat = aInfo.iPixelFormat;

   567 	reqs().iStride = SgAlignedDataStride(aInfo.iSizeInPixels.iWidth, aInfo.iPixelFormat);

   568 	reqs().iOffsetToFirstBuffer = SgOffsetToFirstBuffer(sizeof(TSgImageMetaData));

   569 	reqs().iAlignment = 4;

   570 	reqs().iContiguous = EFalse;

   571 	reqs().iCacheAttrib = aIsCached ? RSurfaceManager::ECached : RSurfaceManager::ENotCached;

   572 	reqs().iOffsetBetweenBuffers = SgOffsetBetweenBuffers(reqs().iStride, aInfo.iSizeInPixels.iHeight);

   573 	reqs().iMappable = ETrue;

   574 	for (TInt i = 0; i < aInfo.iUserAttributeCount; ++i)

   575 		{

   576 		reqs().iSurfaceHints[i].iKey = aInfo.iUserAttributes[i].iUid;

   577 		reqs().iSurfaceHints[i].iValue = aInfo.iUserAttributes[i].iValue;

   578 		reqs().iSurfaceHints[i].iMutable = EFalse;

   579 		}

   580 	TSurfaceId surfaceId;

   581 	err = iDriverImpl.CreateSurface(reqs, surfaceId);

   582 	delete[] hints;

   583 	hints = NULL;

   584 	reqs().iSurfaceHints = NULL;

   585 	if (err != KErrNone)

   586 		{

   587 		return err;

   588 		}

   589 	iSurfaceId = surfaceId;

   590 	RSurfaceManager::TInfoBuf info;

   591 	err = iDriverImpl.SurfaceInfo(surfaceId, info);

   592 	if (err != KErrNone)

   593 		{

   594 		return err;

   595 		}

   596 	err=iDriverImpl.GetBufferOffset(surfaceId,0,iDataOffset);	

   597 	if (err != KErrNone)

   598 		{

   599 		return err;

   600 		}	

   601 	iDataStride = info().iStride;

   602 	RChunk chunk;

   603 	err = iDriverImpl.MapSurface(surfaceId, chunk);

   604 	if (err != KErrNone)

   605 		{

   606 		return err;

   607 		}

   608 	iDataChunk = chunk;

   609 	new(chunk.Base()) TSgImageMetaData(aInfo, iDriverImpl.PixelFormatTable(), aIsCached);

   610 	return err;

   611 	}

   612 

   613 

   614 TInt XSgImageState_SurfaceManager::Construct(const TSgDrawableId& aId)

   615 	{

   616 	const TSgImageId_SurfaceManager& id_SurfaceManager = reinterpret_cast<const TSgImageId_SurfaceManager&>(aId);

   617 	if (id_SurfaceManager.iBufferIndex < 0)

   618 		{

   619 		return KErrNotFound;

   620 		}

   621 	if (id_SurfaceManager.iMetaDataIndex < 0)

   622 		{

   623 		return KErrNotFound;

   624 		}

   625 	TInt err = iDriverImpl.OpenSurface(id_SurfaceManager.iSurfaceId);

   626 	if (err != KErrNone)

   627 		{

   628 		return err;

   629 		}

   630 	iSurfaceId = id_SurfaceManager.iSurfaceId;

   631 	RSurfaceManager::TInfoBuf info;

   632 	err = iDriverImpl.SurfaceInfo(id_SurfaceManager.iSurfaceId, info);

   633 	if (err != KErrNone)

   634 		{

   635 		return err;

   636 		}

   637 	iDataStride = info().iStride;

   638 	if (id_SurfaceManager.iBufferIndex >= info().iBuffers)

   639 		{

   640 		return KErrNotFound;

   641 		}

   642 	iBufferIndex = id_SurfaceManager.iBufferIndex;

   643 	TInt offsetToFirstBuffer;

   644 	err=iDriverImpl.GetBufferOffset(id_SurfaceManager.iSurfaceId,0,offsetToFirstBuffer);

   645 	if (err != KErrNone)

   646 		{

   647 		return err;

   648 		}	

   649 	if ((id_SurfaceManager.iMetaDataIndex + 1) * sizeof(TSgImageMetaData) > offsetToFirstBuffer)

   650 		{

   651 		return KErrNotFound;

   652 		}

   653 	iMetaDataOffset = id_SurfaceManager.iMetaDataIndex * sizeof(TSgImageMetaData);

   654 	RChunk chunk;

   655 	err = iDriverImpl.MapSurface(id_SurfaceManager.iSurfaceId, chunk);

   656 	if (err != KErrNone)

   657 		{

   658 		return err;

   659 		}

   660 	iDataChunk = chunk;

   661 	err=iDriverImpl.GetBufferOffset(id_SurfaceManager.iSurfaceId,id_SurfaceManager.iBufferIndex,iDataOffset);	

   662 	return err;

   663 	}

   664 

   665 

   666 XSgImageState_SurfaceManager::~XSgImageState_SurfaceManager()

   667 	{

   668 	if (!iSurfaceId.IsNull())

   669 		{

   670 		iDriverImpl.CloseSurface(iSurfaceId);

   671 		iDataChunk.Close();

   672 		}

   673 	}

   674 

   675 

   676 const TSgImageMetaData& XSgImageState_SurfaceManager::MetaData() const

   677 	{

   678 	return *reinterpret_cast<TSgImageMetaData*>(iDataChunk.Base() + iMetaDataOffset);

   679 	}

   680 

   681 

   682 TInt XSgImageState_SurfaceManager::GetUserAttributes(TSgUserAttribute* aUserAttributes, TInt aUserAttributeCount) const

   683 	{

   684 	for (TInt i = 0; i < aUserAttributeCount; ++i)

   685 		{

   686 		RSurfaceManager::THintPair hint;

   687 		hint.iKey = aUserAttributes[i].iUid;

   688 		TInt err = iDriverImpl.GetSurfaceHint(iSurfaceId, hint);

   689 		if (err != KErrNone)

   690 			{

   691 			return err;

   692 			}

   693 		aUserAttributes[i].iValue = hint.iValue;

   694 		}

   695 	return KErrNone;

   696 	}

   697 

   698 

   699 TAny* XSgImageState_SurfaceManager::DataAddress() const

   700 	{

   701 #ifdef SYMBIAN_GRAPHICS_AUTOFLUSH_CACHE

   702 	__ASSERT_DEBUG(iCpuAccess != ESgCpuAccessNone, ::Panic(ESgPanicNoCpuAccess));

   703 #endif

   704 	return iDataChunk.Base() + iDataOffset;

   705 	}

   706 

   707 

   708 #ifdef SYMBIAN_GRAPHICS_AUTOFLUSH_CACHE

   709 

   710 TInt XSgImageState_SurfaceManager::BeginDataAccess(TSgCpuAccess aCpuAccess, TBool aIsUserAccess)

   711 	{

   712 	TInt err = XSgImageStateBase::BeginDataAccess(aCpuAccess, aIsUserAccess);

   713 	if (err != KErrNone)

   714 		{

   715 		return err;

   716 		}

   717 	if (aCpuAccess != ESgCpuAccessWriteOnly && MetaData().iIsCached && (MetaData().iPotentialUsage & KSgUsageAllTargets))

   718 		{

   719 		// Cache::SyncMemoryAfterDmaRead() cannot fail so the following should not fail if the arguments are correct

   720 		err = iDriverImpl.SynchronizeCache(iSurfaceId, iBufferIndex, RSurfaceManager::ESyncAfterNonCPUWrite);

   721 		__ASSERT_DEBUG(err == KErrNone, Panic(ESgPanicResourceAdapterGeneral));

   722 		}

   723 	return KErrNone;

   724 	}

   725 

   726 

   727 TInt XSgImageState_SurfaceManager::EndDataAccess(TBool aIsUserAccess)

   728 	{

   729 	TSgCpuAccess prevCpuAccess = iCpuAccess;

   730 	TInt err = XSgImageStateBase::EndDataAccess(aIsUserAccess);

   731 	if (err != KErrNone)

   732 		{

   733 		return err;

   734 		}

   735 	if (prevCpuAccess != ESgCpuAccessReadOnly && MetaData().iIsCached)

   736 		{

   737 		// Cache::SyncMemoryBeforeDmaWrite() cannot fail so the following should not fail if the arguments are correct

   738 		err = iDriverImpl.SynchronizeCache(iSurfaceId, iBufferIndex, RSurfaceManager::ESyncBeforeNonCPURead);

   739 		__ASSERT_DEBUG(err == KErrNone, Panic(ESgPanicResourceAdapterGeneral));

   740 		}

   741 	return KErrNone;

   742 	}

   743 

   744 #endif