1 // Copyright (c) 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 // SurfaceStream.cpp

    15 // CSurfaceStream implementation

    16 

    17 #include <e32base.h>

    18 #include <graphics/suerror.h>

    19 #include <graphics/surfacetypes.h>

    20 #include <hal.h>

    21 #include "surfacestream.h"

    22 #include "openwfcpanic.h"

    23 #include "streammap.h"

    24 #include "symbianstream.h"

    25 #define WFC_INVALID_HANDLE NULL

    26 

    27 const TInt KInvalidIndex = KNoAssociatedScreenNumber;

    28 

    29 struct CSurfaceStream::TCallBackEntry

    30 	{

    31 	typedef SymbianStreamCallback	TSimpleCallback;

    32 	TCallBackEntry();

    33 	void Reset();

    34 	TSimpleCallback iCallBackFunction;

    35 	TAny*			iCallBackClientParam;

    36 	TInt32			iEventMask;

    37 	TInt32          iScreenNumber;

    38 	};

    39 

    40 CSurfaceStream::TCallBackEntry::TCallBackEntry():

    41 iCallBackFunction(NULL),

    42 iCallBackClientParam(NULL),

    43 iEventMask(ESOWF_NoEvent),

    44 iScreenNumber(KNoAssociatedScreenNumber)

    45     {

    46     }

    47 

    48 void CSurfaceStream::TCallBackEntry::Reset()

    49     {

    50     iCallBackFunction = NULL;

    51     iCallBackClientParam = NULL;

    52     iEventMask = ESOWF_NoEvent;

    53     iScreenNumber = KNoAssociatedScreenNumber;

    54     }

    55 

    56 struct CSurfaceStream::TGlobalNotification

    57     {

    58     TGlobalNotification();

    59     void Reset();

    60     TRequestStatus* iStatus;

    61     TThreadId       iThreadId;

    62     TInt            iPendingNotifications;

    63     TInt            iCompletedOkNotifications;

    64     TInt            iCanceledNotifications;

    65     TInt            iOverflowedNotifications;

    66     TInt            iNotVisibleNotifications;

    67     TInt            iOtherNotifications;

    68     };

    69 

    70 

    71 CSurfaceStream::TGlobalNotification::TGlobalNotification():

    72 iStatus(NULL),

    73 iThreadId(0),

    74 iPendingNotifications(0),

    75 iCompletedOkNotifications(0),

    76 iCanceledNotifications(0),

    77 iOverflowedNotifications(0),

    78 iNotVisibleNotifications(0),

    79 iOtherNotifications(0)

    80     {

    81     

    82     }

    83 

    84 void CSurfaceStream::TGlobalNotification::Reset()

    85     {

    86     iStatus = NULL;

    87     iThreadId = 0;

    88     iPendingNotifications = 0;

    89     iCompletedOkNotifications = 0;

    90     iCanceledNotifications = 0;

    91     iOverflowedNotifications = 0;

    92     iNotVisibleNotifications = 0;

    93     iOtherNotifications = 0;

    94     }

    95 

    96 struct CSurfaceStream::TNewGlobalNotifications

    97     {

    98     TNewGlobalNotifications();

    99     TInt iNewAvailableIdx;

   100     TInt iNewDisplayedIdx;

   101     TInt iNewDisplayedXIdx;

   102     };

   103 

   104 CSurfaceStream::TNewGlobalNotifications::TNewGlobalNotifications():

   105 iNewAvailableIdx(KInvalidIndex),

   106 iNewDisplayedIdx(KInvalidIndex),

   107 iNewDisplayedXIdx(KInvalidIndex)

   108     {

   109     }

   110 

   111 CSurfaceStream::Guard::Guard(RFastLock& aLock):

   112 iLock(aLock)

   113     {

   114     iLock.Wait();

   115     }

   116 

   117 CSurfaceStream::Guard::~Guard()

   118     {

   119     iLock.Signal();

   120     }

   121 

   122 CSurfaceStream::CSurfaceStream():

   123 	iSurfaceId(TSurfaceId::CreateNullId()),

   124 	iBufferInfo(NULL),

   125 	iProtected(EFalse),

   126 	iNumberOfScreenAttachedAvailableNotif(0),

   127 	iNumberOfScreenAttachedDisplayedNotif(0),

   128 	iNumberOfScreenAttachedDisplayedXNotif(),

   129 	iFlipState(EFlippedTargetNormal),

   130     iNewFlip(EFlipNotSet)

   131 	{

   132 	iStreamProxySurfaceId.iInternal[TSurfaceId::TSurfaceUsage::EObjectRefField]=

   133 			reinterpret_cast<TInt>(this);

   134 	iStreamProxySurfaceId.iInternal[TSurfaceId::TSurfaceUsage::ETypeClassField]=

   135 			TSurfaceId::EStreamHandle<<TSurfaceId::TSurfaceUsage::ETypeClassShift;

   136 	}

   137 

   138 CSurfaceStream::ContentUpdatedParams::ContentUpdatedParams(TInt aBuffer,

   139                                                            TRequestStatus* aStatusDisplayed, TUint32* aTimeStamp,

   140                                                            TRequestStatus* aStatusDispXTimes, TInt* aDisplayedXTimes,

   141                                                            TRequestStatus* aStatusConsumed, const TRegion* aRegion,

   142                                                            TBool aImmediateAvailable, TInt32 aImmediateVisibility,

   143                                                            const TNewGlobalNotifications& aGlobalNotifications):

   144 iBuffer(aBuffer),

   145 iStatusDisplayed(aStatusDisplayed),

   146 iTimeStamp(aTimeStamp),

   147 iStatusDispXTimes(aStatusDispXTimes),

   148 iDisplayedXTimes(aDisplayedXTimes),

   149 iStatusConsumed(aStatusConsumed),

   150 iRegion(aRegion),

   151 iImmediateAvailable(aImmediateAvailable),

   152 iImmediateVisibility(aImmediateVisibility),

   153 iGlobalNotifications(aGlobalNotifications)

   154     {

   155     

   156     }

   157 

   158 CSurfaceStream::~CSurfaceStream()

   159 	{

   160 	// Cancel any outstanding notifications

   161 	CancelNotifications();

   162     iCallBacks.Close();

   163     iGlobalNotifications.Close();

   164     iBufferChunk.Close();

   165 	

   166     if (!iSurfaceId.IsNull() && iSurfaceId.Type() == TSurfaceTypes::ESurfaceManagerSurface)

   167         {

   168         TRAP_IGNORE(GetSingletonL().SurfaceManager().CloseSurface(iSurfaceId));

   169         }

   170 	

   171 	iRefCountMutex.Close();

   172 	iCallBacksMutex.Close();

   173 	delete [] iBufferInfo;

   174 	}

   175 

   176 CSurfaceStream* CSurfaceStream::NewLC(const TSurfaceId& aId)

   177 	{

   178 	CSurfaceStream* self = new (ELeave)CSurfaceStream();

   179 	CleanupStack::PushL(self);

   180 	self->ConstructL(aId);

   181 	return self;

   182 	}

   183 

   184 void CSurfaceStream::ConstructL(const TSurfaceId& aId)

   185 	{

   186 	User::LeaveIfError(iRefCountMutex.CreateLocal());

   187     User::LeaveIfError(iCallBacksMutex.CreateLocal());

   188    

   189     RSurfaceManager::TInfoBuf infoBuf;  

   190     SurfaceInfoL(aId, infoBuf);

   191 	iInfo = infoBuf();

   192 

   193     COpenWfcStreamMap& stream = GetSingletonL();

   194 	//Create array for TBufferInfo

   195 	iBufferInfo = new(ELeave) TBufferInfo[iInfo.iBuffers];

   196 	for(TInt i = 0; i < iInfo.iBuffers; i++)

   197 		{

   198 		TInt offset = 0;

   199 	    switch(aId.Type())

   200 	        {

   201 	        case TSurfaceTypes::ESurfaceManagerSurface:

   202 	            {

   203 	            User::LeaveIfError(stream.SurfaceManager().GetBufferOffset(iSurfaceId,

   204 	                     i, offset));

   205 	            break;

   206 	            }

   207 	        case TSurfaceId::EScreenSurface:

   208 	            {

   209 	            TInt screenId = SurfaceId().iInternal[TSurfaceId::TScreenSurfaceUsage::EScreenField];

   210 	            User::LeaveIfError(HAL::Get(screenId, HALData::EDisplayOffsetToFirstPixel, offset));

   211 	            break;

   212 	            }

   213 	        default:

   214 	            User::Leave(KErrNotSupported);

   215 	        }

   216 

   217 		iBufferInfo[i].iRefCount = 0;

   218 		iBufferInfo[i].iOffset = offset;

   219 		}

   220 	}

   221 

   222 void CSurfaceStream::SurfaceInfoL(const TSurfaceId& aId, RSurfaceManager::TInfoBuf& aInfoBuf)

   223     {

   224     COpenWfcStreamMap& stream = GetSingletonL();    

   225     switch(aId.Type())

   226         {

   227         case TSurfaceTypes::ESurfaceManagerSurface:

   228             {

   229             iStreamProxySurfaceId.iInternal[TSurfaceId::TSurfaceUsage::EObjectRefField]=

   230                     reinterpret_cast<TInt>(this);

   231             iStreamProxySurfaceId.iInternal[TSurfaceId::TSurfaceUsage::ETypeClassField]=

   232                     TSurfaceId::EStreamHandle<<TSurfaceId::TSurfaceUsage::ETypeClassShift;        

   233             

   234             User::LeaveIfError(stream.SurfaceManager().OpenSurface(aId));            

   235             iSurfaceId = aId;

   236             User::LeaveIfError(stream.SurfaceManager().SurfaceInfo(iSurfaceId, aInfoBuf));

   237             break;

   238             }

   239         case TSurfaceId::EScreenSurface:

   240             {

   241             // DSA surface only has one buffer

   242             aInfoBuf().iBuffers = 1;

   243             

   244             TInt screenId = aId.iInternal[TSurfaceId::TScreenSurfaceUsage::EScreenField];

   245             TInt width;

   246             User::LeaveIfError(HAL::Get(screenId, HALData::EDisplayXPixels, width));

   247                         

   248             TInt height;

   249             User::LeaveIfError(HAL::Get(screenId, HALData::EDisplayYPixels, height));

   250             

   251             aInfoBuf().iSize = TSize(width, height);

   252             

   253             TInt bpp = 0;

   254             User::LeaveIfError(HAL::Get(screenId, HALData::EDisplayBitsPerPixel, bpp));

   255 

   256             TUidPixelFormat pixelFormat = static_cast<TUidPixelFormat> (aId.iInternal[TSurfaceId::TScreenSurfaceUsage::ETypeGuidField]);

   257             if (!pixelFormat)

   258                 {

   259                 //if (bpp==12 || bpp==4))   //This allows low-color indices to be semi-functionally tested

   260                 if (bpp==12)

   261                     {

   262                     pixelFormat = EUidPixelFormatXRGB_4444;

   263                     }

   264                 else if (bpp == 16)

   265                     {

   266                     pixelFormat = EUidPixelFormatRGB_565;

   267                     }

   268                 else if (bpp== 24 || bpp==32)

   269                     {

   270                     pixelFormat = EUidPixelFormatARGB_8888;

   271                     }

   272                 else

   273                     {

   274                     User::Leave(KErrNotSupported);

   275                     }

   276 

   277                 }

   278             aInfoBuf().iPixelFormat = pixelFormat;

   279             

   280 #ifdef  SYMBIAN_ROTATION_MODE_CHANGES

   281             TInt displayMode = aId.iInternal[TSurfaceId::TScreenSurfaceUsage::EHalField];

   282 #else

   283             TInt displayMode = 0;

   284             User::LeaveIfError(HAL::Get(screenId, HALData::EDisplayMode, displayMode));

   285 #endif            

   286             

   287 #if defined(SYMBIAN_ROTATION_MODE_CHANGES)

   288             if (displayMode & TSurfaceId::TScreenSurfaceUsage::EHalFlippedFlag) // 90 | 270 degree rotation

   289                 {

   290                 // Swap dimensions and recalculate stride. Assume no padding for now.

   291                 aInfoBuf().iSize.iWidth = height;

   292                 aInfoBuf().iSize.iHeight = width;

   293                 //"vertical" stride has already been fetched

   294                 }

   295 #elif defined(SYMBIAN_ROTATION_CHANGES)

   296             if (aSurface.iInternal[1] & (2 | 8))    // 90 | 270 degree rotation

   297                 {

   298                 // Swap dimensions and recalculate stride. Assume no padding for now.

   299                 aInfoBuf().iSize.iWidth = height;

   300                 aInfoBuf().iSize.iHeight = width;

   301                 aInfoBuf().iStride = infoBuf().iSize.width * bpp;

   302                 }

   303 #endif            

   304             

   305             TInt stride = displayMode;

   306             User::LeaveIfError(HAL::Get(screenId, HALData::EDisplayOffsetBetweenLines, stride));

   307 

   308             aInfoBuf().iStride = stride;             

   309             

   310             iSurfaceId = aId;

   311             break;

   312             }

   313         default:

   314             User::Leave(KErrNotSupported);

   315         } 

   316     }

   317 

   318 COpenWfcStreamMap& CSurfaceStream::GetSingletonL()

   319 	{

   320 	return COpenWfcStreamMap::InstanceL();

   321 	}

   322 

   323 /**

   324 	Helper to resolve handle to stream object

   325 **/

   326 /*static*/

   327 CSurfaceStream* CSurfaceStream::FromHandle(SymbianStreamType aNativeStreamHandle)

   328 	{

   329 	if (aNativeStreamHandle)

   330 		{

   331 		if (aNativeStreamHandle->Type()==TSurfaceId::EStreamHandle)

   332 			{

   333 			return reinterpret_cast<CSurfaceStream*>(aNativeStreamHandle->iInternal[TSurfaceId::TSurfaceUsage::EObjectRefField]);

   334 			}

   335 		}

   336 	return NULL;

   337 	}

   338 

   339 /**

   340 	Helper to resolve handle to stream object

   341 **/

   342 SymbianStreamType CSurfaceStream::ToHandle()

   343 	{

   344 	if (this)

   345 		{

   346 		return &iStreamProxySurfaceId;

   347 		}

   348 	else

   349 		{

   350 		return NULL;

   351 		}

   352 	}

   353 

   354 

   355 /**	Returns internal surface ID.

   356  *

   357  * @return surface id asociated with this stream

   358  **/

   359 const TSurfaceId& CSurfaceStream::SurfaceId()const

   360 	{

   361 	return iSurfaceId;

   362 	}

   363 

   364 /*!

   365  * \brief Increase stream's reference count by one.

   366  *

   367  */

   368  void CSurfaceStream::AddReference()

   369 	 {

   370 	 iRefCountMutex.Wait();

   371 	 iRefCount++;

   372 	 iRefCountMutex.Signal();

   373 

   374 	 }

   375 

   376 /*!

   377  * \internal

   378  *

   379  * \brief Returns flag if reference count is now zero.

   380  *

   381  */

   382 TBool	CSurfaceStream::RemainingReference()

   383 	{

   384 	 iRefCountMutex.Wait();

   385 	 TBool countZero=iRefCount==0;

   386 	 iRefCountMutex.Signal();

   387 	 return countZero;

   388 	}

   389 

   390 

   391 /*!

   392  * \brief Decrease stream's reference count by one and destroy

   393  * the stream, if the reference count goes to zero.

   394  *

   395  * All acquired read & write buffers must be released

   396  * before calling WFC_Native_Destroy.

   397  *

   398  */

   399 void CSurfaceStream::ReleaseReference()

   400 	{

   401 	iRefCountMutex.Wait();

   402 	--iRefCount;

   403 	if (iRefCount < 1)

   404 		{

   405 		// it is required to signal the mutex before calling LockDestroy()

   406 		iRefCountMutex.Signal();

   407 		TRAP_IGNORE(GetSingletonL().LockDestroy(this));

   408 		}

   409 	else

   410 		{

   411 		iRefCountMutex.Signal();

   412 		}

   413 	 }

   414 

   415 /*!

   416  * \brief Get stream "frame header". Can be used to query

   417  * all or some of the frame properties.

   418  *

   419  * \param width Pointer to location where width parameter should be saved

   420  * \param height Pointer to location where height parameter should be saved

   421  * \param stride Pointer to location where stride (row size in bytes)

   422  * parameter should be saved

   423  * \param pixelSize Pointer to location where pizelSize (pixel size in bytes) if the format has more than 8 bits.

   424  *                  For the formats with fewer than 8 bits per pixel, or ones that do not use packed pixel 

   425  *                  the parameter is a negative number            

   426  * parameter should be saved

   427 

   428  * Passing a NULL pointer implies that particular

   429  * value is of no interest to caller. E.g.

   430  *   owfNativeStreamGetHeader(stream, &w, &h, NULL, NULL, NULL);

   431  * would only fetch width & height parameters.

   432  */

   433 void CSurfaceStream::GetHeader(  khronos_int32_t* aWidth,

   434                            khronos_int32_t* aHeight,

   435                            khronos_int32_t* aStride,

   436                            SymOwfPixelFormat* aFormat,

   437                            khronos_int32_t* aPixelSize)

   438 	 {

   439 	 Guard g1(iRefCountMutex);

   440 	 if (aWidth)

   441 		 {

   442 		 if (iFlipState == EFlippedTargetFlipped)

   443 		     {

   444 	         *aWidth = static_cast<khronos_int32_t>(iInfo.iSize.iHeight);

   445 		     }

   446 		 else

   447 		     {

   448              *aWidth = static_cast<khronos_int32_t>(iInfo.iSize.iWidth);

   449 		     }

   450 		 }

   451 	 

   452 	 if (aHeight)

   453 		 {

   454          if (iFlipState == EFlippedTargetFlipped)

   455              {

   456              *aHeight = static_cast<khronos_int32_t>(iInfo.iSize.iWidth);

   457              }

   458          else

   459              {

   460              *aHeight = static_cast<khronos_int32_t>(iInfo.iSize.iHeight);

   461              }

   462 		 }

   463 	 if (aStride)

   464 		 {

   465          if (iFlipState == EFlippedTargetFlipped)

   466              {

   467              *aStride = Stride(iInfo.iSize.iHeight, iInfo.iPixelFormat);

   468              }

   469          else

   470              {

   471              *aStride = static_cast<khronos_int32_t>(iInfo.iStride);

   472              }

   473 		 }

   474 	 if (aFormat)

   475 		 {

   476 		 *aFormat=iInfo.iPixelFormat;

   477 		 }

   478 	 if (aPixelSize)

   479 		 {

   480 		*aPixelSize = static_cast<khronos_int32_t>(BytesPerPixel(iInfo.iPixelFormat));

   481 		 }

   482 	 }

   483 

   484 /*!

   485  * \brief Acquires read buffer for stream. For > 1 buffer

   486  * streams this function doesn't block, but simply returns

   487  * WFC_INVALID_HANDLE if no buffer is available for reading.

   488  * For 1 buffer stream the caller is blocked until the buffer

   489  * is ready for reading (the reader has committed the buffer,

   490  * that is.)

   491  *

   492  *

   493  * \return WFC_INVALID_HANDLE if no buffer is available or

   494  * handle to last committed buffer.

   495  *

   496  * An example sequence for 3 buffer stream where

   497  * producer produces frames approx. after every ~5th time unit.

   498  * Consumer consumes buffers at constant rate of 1buf/time unit.

   499  * Pframe is the number/handle of buffer that is being written by

   500  * the producer (let's assume that it takes 2 time units

   501  * for producer to produce a frame/buffer.) Cframe is the number/

   502  * handle of the buffer the consumer receives from AcquireReadBuffer().

   503  * "i" stands for WFC_INVALID_HANDLE:

   504  *

   505  * \code

   506  * Time:   0    5    10   15   20   25

   507  * Pframe: 0    1    2    0    1    ...

   508  * Cframe: ii00000111112222200000111...

   509  * \endcode

   510  */

   511 SymbianStreamBuffer CSurfaceStream::AcquireReadBuffer()

   512 	 {

   513 	 SymbianStreamBuffer buffer = WFC_INVALID_HANDLE;

   514 

   515 	 iRefCountMutex.Wait();

   516 	 TInt index = GetReadBufferIndex();

   517      buffer = IndexToReadHandle(index);

   518      ++(iBufferInfo[index].iRefCount);

   519 	 iRefCountMutex.Signal();

   520 	 AddReference();

   521 	 return buffer;

   522 	 }

   523 

   524 /*!

   525  * \brief Releases read buffer.

   526  *

   527  * When read buffer is released, it is marked as clean to

   528  * be written again, unless it is the only committed buffer

   529  * in which case it is recycled so that the same buffer

   530  * can be read again (as long as no new buffers are committed

   531  * by the producer)

   532  *

   533  * \param buf Buffer handle. Must be valid read buffer handle for

   534  * given stream.

   535  */

   536 TInt CSurfaceStream::ReleaseReadBuffer(SymbianStreamBuffer aBuf)

   537 	 {

   538 	 TInt index = BufferHandleToIndex(aBuf);

   539 	 if(index < 0 || index >= iInfo.iBuffers)

   540 		 {

   541 		 return KErrBadHandle;

   542 		 }

   543 

   544      iRefCountMutex.Wait();

   545 

   546       __ASSERT_DEBUG(iBufferInfo[index].iRefCount > 0, 

   547 			 (iRefCountMutex.Signal(),Panic(EOwfPanicSurfaceStreamBufferNotLocked)));

   548 

   549       --(iBufferInfo[index].iRefCount);

   550      

   551      iRefCountMutex.Signal();

   552      ReleaseReference();

   553      return KErrNone;

   554 	 }

   555 

   556 /*!

   557  * \brief Acquires write buffer for stream.

   558  *

   559  * Returns handle to a buffer that can be used to write

   560  * data into stream. If no clean buffer is available,

   561  * invalid handle is returned.

   562  *

   563  *

   564  * \return Handle to a writable buffer

   565  */

   566 SymbianStreamBuffer CSurfaceStream::AcquireWriteBuffer()

   567 	 {

   568 	 SymbianStreamBuffer   buffer = WFC_INVALID_HANDLE;

   569 

   570      iRefCountMutex.Wait();

   571      TInt index = GetWriteBufferIndex();

   572      //Writers are currently not blocked in single buffered,

   573      //but if proper signalling was implemented then they could be blocked

   574      //Ideally, make signalling/blocking a parameter flag of AcquireWriteBuffer

   575      if (iInfo.iBuffers>1 && iBufferInfo[index].iRefCount > 0)

   576        	{

   577         buffer = WFC_INVALID_HANDLE;

   578       	}

   579      else

   580        	{

   581         buffer = IndexToWriteHandle(index);

   582         ++(iBufferInfo[index].iRefCount);

   583         iAcquiredWriteBuffer = buffer;

   584        	}

   585     iRefCountMutex.Signal();

   586     if (buffer)

   587     	{

   588     	AddReference();

   589     	}

   590     return buffer;

   591 	}

   592 

   593 /*!

   594  * \brief Releases write buffer to stream.

   595  * Released buffer is made new front buffer, i.e., producer is expected

   596  * to release buffer is the same order they were acquired.

   597  *

   598  * \param buf Buffer handle. Must be valid write buffer handle

   599  * for given stream.

   600  */

   601 void CSurfaceStream::ReleaseWriteBuffer(SymbianStreamBuffer aBuf)

   602 	 {

   603 	 TInt index = BufferHandleToIndex(aBuf);

   604 	 if(index < 0 || index >= iInfo.iBuffers)

   605 		 {

   606 		 return;

   607 		 }

   608 

   609 	 iRefCountMutex.Wait();

   610 

   611      __ASSERT_DEBUG(iBufferInfo[index].iRefCount > 0,

   612 			(iRefCountMutex.Signal(),Panic(EOwfPanicSurfaceStreamBufferNotLocked)));

   613 

   614      __ASSERT_DEBUG((iAcquiredWriteBuffer == aBuf) || (iAcquiredWriteBuffer == BUFFER_WRITE_UPDATE_OVERWRITE),

   615 			(iRefCountMutex.Signal(),Panic(EOwfPanicSurfaceStreamBufferNotLocked)));

   616 

   617 	 if (iAcquiredWriteBuffer != BUFFER_WRITE_UPDATE_OVERWRITE)

   618 		 {

   619 		 // Update read buffer to point to buffer just finished writing

   620 		 SetReadBufferIndex(index);

   621 		 }

   622 	 iAcquiredWriteBuffer = WFC_INVALID_HANDLE;

   623 

   624      --(iBufferInfo[index].iRefCount);

   625 	 

   626      if (iNewFlip != EFlipNotSet)

   627          {

   628          iFlipState = iNewFlip;

   629          iNewFlip = EFlipNotSet;

   630          }

   631      

   632 	 iRefCountMutex.Signal();

   633 

   634 	 NotifyObservers(ESOWF_EventComposed);

   635 	 ReleaseReference();	//Note this means this NotifyObservers can never get the rug pulled out

   636 	 }

   637 

   638 

   639 void CSurfaceStream::SetReadBufferIndex(TInt aIndex)

   640 	{

   641 	__ASSERT_DEBUG(aIndex >= 0 && aIndex < iInfo.iBuffers,

   642 			(iRefCountMutex.Signal(),Panic(EOwfPanicSurfaceStreamBufferIndexOutOfBounds)));

   643 	iReadBuffer = aIndex;

   644 	}

   645 

   646 TInt CSurfaceStream::GetReadBufferIndex()

   647 	{

   648 	return iReadBuffer;

   649 	}

   650 TInt CSurfaceStream::GetWriteBufferIndex()

   651 	{

   652 	return (iReadBuffer+1)%iInfo.iBuffers;

   653 	}

   654 

   655 /*! \brief Returns pointer to pixel buffer.

   656  *

   657  * \param buffer Handle of buffer

   658  */

   659 void* CSurfaceStream::GetBufferPtrL(SymbianStreamBuffer aBuffer)

   660 	 {

   661      TInt bufferIndex = BufferHandleToIndex(aBuffer);  

   662      Guard g1(iRefCountMutex);

   663      __ASSERT_DEBUG(iBufferInfo[bufferIndex].iRefCount > 0,

   664              (iRefCountMutex.Signal(),Panic(EOwfPanicSurfaceStreamBufferNotLocked)));

   665              

   666      switch (SurfaceId().Type())

   667          {

   668          case TSurfaceTypes::ESurfaceManagerSurface:

   669              {                         

   670              if (iBufferChunk.Handle() == 0)

   671                  {

   672                  RChunk threadChunk;

   673                  User::LeaveIfError(GetSingletonL().SurfaceManager().MapSurface(iSurfaceId, threadChunk));

   674 				 CleanupClosePushL(threadChunk);

   675 

   676 				 RChunk duplicateChunk;

   677 				 duplicateChunk.SetHandle(threadChunk.Handle());

   678 				 User::LeaveIfError(duplicateChunk.Duplicate(RThread(), EOwnerProcess));

   679 

   680                  iBufferChunk.SetHandle(duplicateChunk.Handle());

   681 				 CleanupStack::PopAndDestroy(&threadChunk);

   682                  }

   683              break;

   684              }

   685 	     case TSurfaceId::EScreenSurface:

   686 	         {

   687 	         if (iBufferChunk.Handle() == 0)

   688 	             {

   689 	             TInt val = 0;

   690 	             TInt screenId = SurfaceId().iInternal[TSurfaceId::TScreenSurfaceUsage::EScreenField];

   691 	             User::LeaveIfError(HAL::Get(screenId, HALData::EDisplayMemoryHandle, val));

   692                 

   693 	             RChunk threadChunk;

   694 				 CleanupClosePushL(threadChunk);

   695 	             User::LeaveIfError(threadChunk.SetReturnedHandle(val));

   696 

   697 				 RChunk duplicateChunk;

   698 				 duplicateChunk.SetHandle(threadChunk.Handle());

   699 				 User::LeaveIfError(duplicateChunk.Duplicate(RThread(), EOwnerProcess));

   700 

   701 	             iBufferChunk.SetHandle(duplicateChunk.Handle());

   702 	             CleanupStack::PopAndDestroy(&threadChunk);

   703 	             }

   704 	         break;

   705 	         }

   706 	     default:

   707 	         User::Leave(KErrNotSupported);

   708 	     }

   709 	 

   710      TUint8 *pBufferStart = iBufferChunk.Base() + iBufferInfo[bufferIndex].iOffset;

   711      return static_cast<void*>(pBufferStart);	 

   712 	 }

   713 

   714 void CSurfaceStream::SetProtectionFlag(TBool aFlag)

   715 	{

   716 	iRefCountMutex.Wait();

   717 	if (aFlag!=iProtected)

   718 		{

   719 		iProtected=aFlag;

   720 		iRefCountMutex.Signal();

   721 		if (aFlag)

   722 			{

   723 			AddReference();

   724 			}

   725 		else

   726 			{

   727 			ReleaseReference();

   728 			}

   729 		}

   730 	else

   731 		{

   732 		iRefCountMutex.Signal();

   733 		}

   734 	}

   735 

   736 TInt CSurfaceStream::BytesPerPixel(TUidPixelFormat aPixelFormat)

   737 	{

   738 	switch (aPixelFormat)

   739 		{

   740 		case EUidPixelFormatXRGB_8888:

   741 		case EUidPixelFormatARGB_8888:

   742 		case EUidPixelFormatBGRX_8888:

   743 		case EUidPixelFormatXBGR_8888:

   744 		case EUidPixelFormatBGRA_8888:

   745 		case EUidPixelFormatABGR_8888:	

   746 		case EUidPixelFormatABGR_8888_PRE:

   747 		case EUidPixelFormatARGB_8888_PRE:

   748 		case EUidPixelFormatBGRA_8888_PRE:

   749 		case EUidPixelFormatARGB_2101010:

   750 		case EUidPixelFormatABGR_2101010:

   751 			return 4;

   752 		case EUidPixelFormatBGR_888:

   753 		case EUidPixelFormatRGB_888:

   754 			return 3;

   755 		case EUidPixelFormatXRGB_4444:

   756 		case EUidPixelFormatARGB_4444:

   757 		case EUidPixelFormatXBGR_4444:

   758 		case EUidPixelFormatRGB_565:

   759 		case EUidPixelFormatBGR_565:

   760 		case EUidPixelFormatARGB_1555:

   761 		case EUidPixelFormatXRGB_1555:

   762 		case EUidPixelFormatARGB_8332:

   763 		case EUidPixelFormatBGRX_5551:

   764 		case EUidPixelFormatBGRA_5551:

   765 		case EUidPixelFormatBGRA_4444:

   766 		case EUidPixelFormatBGRX_4444:

   767 		case EUidPixelFormatAP_88:

   768 			return  2;

   769 		case EUidPixelFormatRGB_332:

   770 		case EUidPixelFormatBGR_332:

   771 	    case EUidPixelFormatA_8:

   772 	    case EUidPixelFormatL_8:

   773 	        return  1;

   774 		case EUidPixelFormatP_8:

   775 			return -1;

   776 	    case EUidPixelFormatP_4:

   777 	    case EUidPixelFormatL_4:

   778 	    	return -2;

   779 	    case EUidPixelFormatL_2:

   780 	    case EUidPixelFormatP_2:

   781 	    	return -4;

   782 	    case EUidPixelFormatL_1 :

   783             return -8;

   784 		default:

   785 			{

   786 			return 0;

   787 			}

   788 		}

   789 	}

   790 

   791 SymbianStreamBuffer CSurfaceStream::IndexToReadHandle(TInt aIndex)

   792 	{

   793 	return static_cast<SymbianStreamBuffer>(aIndex + BUFFER_READ_HANDLE_BASE);

   794 	}

   795 

   796 SymbianStreamBuffer CSurfaceStream::IndexToWriteHandle(TInt aIndex)

   797 	{

   798 	return static_cast<SymbianStreamBuffer>(aIndex + BUFFER_WRITE_HANDLE_BASE);

   799 	}

   800 

   801 TInt CSurfaceStream::BufferHandleToIndex(SymbianStreamBuffer aBuff)

   802 	{

   803 	TInt retVal= (aBuff > 0) ? (aBuff&0xFF) : (aBuff - BUFFER_READ_HANDLE_BASE);

   804 	__ASSERT_DEBUG(retVal>=0,User::Invariant());

   805 	__ASSERT_DEBUG(retVal<iInfo.iBuffers,User::Invariant());

   806 	return retVal;

   807 	}

   808 

   809 

   810 

   811 

   812 void CSurfaceStream::RequestComplete(TThreadId& aThreadId, TRequestStatus*& aRequestStatus, TInt& aGlobalIndexArray, TInt aStatus)

   813     {

   814     if (aRequestStatus)

   815         {

   816         if (aGlobalIndexArray != KInvalidIndex)

   817             {

   818             TGlobalNotification& globalNotification = iGlobalNotifications[aGlobalIndexArray];

   819             --globalNotification.iPendingNotifications;

   820             switch (aStatus)

   821                 {

   822                 case KErrNone:

   823                     globalNotification.iCompletedOkNotifications++;

   824                     break;

   825                 case KErrOverflow:

   826                     globalNotification.iOverflowedNotifications++;

   827                     break;

   828                 case KErrCancel:

   829                     globalNotification.iCanceledNotifications++;

   830                     break;

   831                 case KErrNotVisible:

   832                     globalNotification.iNotVisibleNotifications++;

   833                     break;

   834                 default:

   835                     globalNotification.iOtherNotifications++;

   836                 }

   837             NFLOG(("### CSurfaceStream::RequestComplete globalRequestStatus[%d] iPendingNotifications(%d) "

   838                     "iCompletedOkNotifications(%d)"

   839                     "iOverflowedNotifications(%d)"

   840                     "iCanceledNotifications(%d)"

   841                     "iNotVisibleNotifications(%d)"

   842                     "iOtherNotifications(%d)"

   843                     "requestStatus(%p)",

   844                     aGlobalIndexArray, 

   845                     globalNotification.iPendingNotifications, 

   846                     globalNotification.iCompletedOkNotifications, 

   847                     globalNotification.iOverflowedNotifications,

   848                     globalNotification.iCanceledNotifications,

   849                     globalNotification.iNotVisibleNotifications,

   850                     globalNotification.iOtherNotifications,

   851                     aStatus));

   852             

   853             if (globalNotification.iStatus && globalNotification.iPendingNotifications == 0)

   854                 {

   855                 TInt status;

   856                 if (globalNotification.iCompletedOkNotifications > 0)

   857                     {

   858                     status = KErrNone;

   859                     }

   860                 else if (globalNotification.iOverflowedNotifications > 0)

   861                     {

   862                     status = KErrOverflow;

   863                     }

   864                 else if (globalNotification.iNotVisibleNotifications > 0)

   865                     {

   866                     status = KErrNotVisible;

   867                     }

   868                 else if (globalNotification.iCanceledNotifications > 0)

   869                     {

   870                     status = KErrCancel;

   871                     }

   872                 else

   873                     {

   874                     status = KErrGeneral;

   875                     }

   876                     

   877                 RThread thread;

   878                 if (thread.Open(globalNotification.iThreadId) == KErrNone)

   879                     {

   880                     NFLOG(("### CSurfaceStream::RequestComplete globalIndex[%d] aRequestComplete(0x%x) status(%d)",

   881                             aGlobalIndexArray, iGlobalNotifications[aGlobalIndexArray].iStatus, status));

   882                     thread.RequestComplete(globalNotification.iStatus, status);

   883                     thread.Close();

   884                     iGlobalNotifications[aGlobalIndexArray].Reset();

   885                     }

   886                 }

   887             }

   888         else

   889             {

   890             RThread thread;

   891             if (thread.Open(aThreadId) == KErrNone)

   892                 {

   893                 NFLOG(("### CSurfaceStream::RequestComplete aRequestStatus(0x%x) aThreadId(0x%x) aStatus(%d)",

   894                         aRequestStatus, aThreadId, aStatus));

   895                 thread.RequestComplete(aRequestStatus, aStatus);

   896                 thread.Close();

   897                 }

   898             }

   899         aRequestStatus = NULL;

   900         aThreadId = 0;

   901         }

   902     aGlobalIndexArray = KInvalidIndex;

   903     }

   904 

   905 int  CSurfaceStream::AddObserver(SymbianStreamCallback aObserver, 

   906                                  TInt32 aEvent,

   907                                  TInt32 aScreenNumber,

   908                                  void* aData)

   909      {

   910      if (!(aEvent & ESOWF_AllEventsMask) || !aData)

   911          {

   912          // early exit if the parameters are invalid

   913          return KErrArgument;

   914          }

   915      

   916      TInt  errRet = KErrNone;

   917      TCallBackEntry newEntry;

   918      

   919      Guard g2(iCallBacksMutex);

   920      Guard g1(iRefCountMutex);

   921      

   922      // Let's do the check that we dont have an other similar observer already inserted

   923      // traverse the whole aobservers list to see if there is already an observer in place

   924      TInt  idx = iCallBacks.Count();

   925      while(idx--)

   926          {

   927          if (iCallBacks[idx].iEventMask == aEvent)

   928              {

   929              switch (aEvent)

   930                  {

   931                  case ESOWF_EventAvailable:

   932                  case ESOWF_EventDisplayed:

   933                  case ESOWF_EventDisplayedX:

   934                      // these are events related to a context and identified by a screen number

   935                      if (iCallBacks[idx].iScreenNumber == aScreenNumber)

   936                          {

   937                          // nothing else to do, the entry is already created

   938                          return KErrOverflow;

   939                          }

   940                      break;

   941                      

   942                  case ESOWF_EventComposed:

   943                  case ESOWF_EventUpdated:

   944                      if (iCallBacks[idx].iCallBackClientParam == aData)

   945                          {

   946                          // nothing else to do, the entry is already created

   947                          return KErrOverflow;

   948                          }

   949                      break;

   950                      

   951                  default:

   952                      // something really unexpected, let's invalidate the entry

   953                      // possible memomry leaks but we are, still, alive and running.

   954                      iCallBacks[idx].Reset();

   955                      break;

   956                  }

   957              }

   958          }

   959      

   960      // we need to add a new observer to the list

   961     newEntry.iCallBackFunction = aObserver;

   962     newEntry.iEventMask = aEvent;

   963     newEntry.iScreenNumber = aScreenNumber;

   964     TInt trapErr;

   965     switch (aEvent)

   966         {

   967         case ESOWF_EventUpdated:

   968         case ESOWF_EventComposed:

   969             newEntry.iCallBackClientParam = aData;

   970             break;

   971         

   972         case ESOWF_EventAvailable:

   973             {

   974             TNotificationAvailable* available = NULL;

   975             TRAP(trapErr,available = new(ELeave) TNotificationAvailable());

   976             if (trapErr != KErrNone)

   977                 {

   978                 return trapErr;

   979                 }

   980             ResetCallBackData(available, aEvent);

   981             available->iSerialNumber = KInitialContextSerialNumber;

   982             newEntry.iCallBackClientParam = available;

   983             }

   984             break;

   985         

   986         case ESOWF_EventDisplayed:

   987             {

   988             TNotificationDisplayed* displayed = NULL;

   989             TRAP(trapErr,displayed = new(ELeave) TNotificationDisplayed());

   990             if (trapErr != KErrNone)

   991                 {

   992                 return trapErr;

   993                 }

   994             ResetCallBackData(displayed, aEvent);

   995             displayed->iSerialNumber = KInitialContextSerialNumber;

   996             newEntry.iCallBackClientParam = displayed;

   997             }

   998             break;

   999         

  1000         case ESOWF_EventDisplayedX:

  1001             {

  1002             TNotificationDisplayedX* displayedX = NULL;

  1003             TRAP(trapErr,displayedX = new(ELeave) TNotificationDisplayedX()); 

  1004             if (trapErr != KErrNone)

  1005                 {

  1006                 return trapErr;

  1007                 }

  1008             ResetCallBackData(displayedX, aEvent);

  1009             displayedX->iSerialNumber = KInitialContextSerialNumber;

  1010             newEntry.iCallBackClientParam = displayedX;

  1011             }

  1012             break;

  1013         

  1014         default:

  1015             return KErrArgument;

  1016         }

  1017      

  1018      // look for an entry that already exists

  1019      idx = iCallBacks.Count();

  1020      

  1021      while(idx--)

  1022          {

  1023          // the free entry positions are identified using event mask

  1024          if (iCallBacks[idx].iEventMask == ESOWF_NoEvent) break;

  1025          }

  1026      

  1027      if (idx > -1)

  1028          {

  1029          // ok, we got an existing, free entry

  1030          iCallBacks[idx] = newEntry;

  1031          }

  1032      else

  1033          {

  1034          errRet = iCallBacks.Append(newEntry);

  1035          if (errRet != KErrNone)

  1036              {

  1037              return errRet;

  1038              }

  1039          }

  1040 

  1041      switch (aEvent)

  1042          {

  1043          case ESOWF_EventAvailable:

  1044              iNumberOfScreenAttachedAvailableNotif++;

  1045              break;

  1046              

  1047          case ESOWF_EventDisplayed:

  1048              iNumberOfScreenAttachedDisplayedNotif++;

  1049              break;

  1050              

  1051          case ESOWF_EventDisplayedX:

  1052              iNumberOfScreenAttachedDisplayedXNotif++;

  1053              break;

  1054              

  1055          default:

  1056              break;

  1057          

  1058          }

  1059      

  1060      return errRet;

  1061      }

  1062 

  1063 

  1064 int CSurfaceStream::RemoveObserver(TInt32 aEvents, void* aData)

  1065     {

  1066     NFLOG(("ENTER ###CSurfaceStream::RemoveObserver() events(%d) data(0x%x)", aEvents, aData));

  1067     if (!(aEvents & ESOWF_AllEventsMask))

  1068     {

  1069         NFLOG(("EXIT ###CSurfaceStream::RemoveObserver() ERROR: KErrArgument"));

  1070         return KErrArgument;

  1071     }

  1072      

  1073     Guard g2(iCallBacksMutex);

  1074     Guard g1(iRefCountMutex);

  1075     

  1076     TInt32 notFoundEvent = aEvents;

  1077     TInt count = iCallBacks.Count();

  1078     TInt32 susScreenNumber = KNoAssociatedScreenNumber;

  1079     

  1080     if (aData)

  1081         {

  1082         susScreenNumber = *(((TInt32*)aData));

  1083         }

  1084         

  1085     while (count-- && notFoundEvent)

  1086         {

  1087         TInt32 currentEvent = iCallBacks[count].iEventMask;

  1088         if (currentEvent & aEvents)

  1089             {

  1090             void* callBackData = iCallBacks[count].iCallBackClientParam;

  1091             switch (currentEvent)

  1092                 {

  1093                 case ESOWF_EventDisplayed:

  1094                     if (callBackData && (!aData || (iCallBacks[count].iScreenNumber == susScreenNumber)))

  1095                         {

  1096                         Displayed(ESOWF_ObserverCancel, iCallBacks[count].iScreenNumber, NULL, callBackData, NULL);

  1097                         delete callBackData;

  1098                         iCallBacks[count].Reset();

  1099                         if (iNumberOfScreenAttachedDisplayedNotif > 0)

  1100                             {

  1101                             iNumberOfScreenAttachedDisplayedNotif--;

  1102                             }

  1103                         notFoundEvent &= ~currentEvent;

  1104                         }

  1105                     break;

  1106              

  1107                 case ESOWF_EventAvailable:

  1108                     if (callBackData && (!aData || (iCallBacks[count].iScreenNumber == susScreenNumber)))

  1109                         {

  1110                         Available(ESOWF_ObserverCancel, iCallBacks[count].iScreenNumber, NULL, callBackData, NULL);

  1111                         delete callBackData;

  1112                         iCallBacks[count].Reset();

  1113                         if (iNumberOfScreenAttachedAvailableNotif > 0)

  1114                             {

  1115                             iNumberOfScreenAttachedAvailableNotif--;

  1116                             }

  1117                         notFoundEvent &= ~currentEvent;

  1118                         }                       

  1119                     break;

  1120              

  1121                 case ESOWF_EventDisplayedX:

  1122                     if (callBackData && (!aData || (iCallBacks[count].iScreenNumber == susScreenNumber)))

  1123                         {

  1124                         DisplayedXTimes(ESOWF_ObserverCancel, iCallBacks[count].iScreenNumber, NULL, callBackData, NULL);

  1125                         delete callBackData;

  1126                         iCallBacks[count].Reset();

  1127                         if (iNumberOfScreenAttachedDisplayedXNotif)

  1128                             {

  1129                             iNumberOfScreenAttachedDisplayedXNotif--;

  1130                             }

  1131                         notFoundEvent &= ~currentEvent;

  1132                         }                   

  1133                     break;

  1134