// Copyright (c) 2009-2010 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:

// SurfaceStream.cpp

// CSurfaceStream implementation

#include <e32base.h>

#include <graphics/suerror.h>

#include <graphics/surfacetypes.h>

#include <hal.h>

#include "surfacestream.h"

#include "openwfcpanic.h"

#include "streammap.h"

#include "symbianstream.h"

#define WFC_INVALID_HANDLE NULL

const TInt KInvalidIndex = KNoAssociatedScreenNumber;

struct CSurfaceStream::TCallBackEntry

	{

	typedef SymbianStreamCallback	TSimpleCallback;

	TCallBackEntry();

	void Reset();

	TSimpleCallback iCallBackFunction;

	TAny*			iCallBackClientParam;

	TInt32			iEventMask;

	TInt32          iScreenNumber;

	};

CSurfaceStream::TCallBackEntry::TCallBackEntry():

iCallBackFunction(NULL),

iCallBackClientParam(NULL),

iEventMask(ESOWF_NoEvent),

iScreenNumber(KNoAssociatedScreenNumber)

    {

    }

void CSurfaceStream::TCallBackEntry::Reset()

    {

    iCallBackFunction = NULL;

    iCallBackClientParam = NULL;

    iEventMask = ESOWF_NoEvent;

    iScreenNumber = KNoAssociatedScreenNumber;

    }

struct CSurfaceStream::TGlobalNotification

    {

    TGlobalNotification();

    void Reset();

    TRequestStatus* iStatus;

    TThreadId       iThreadId;

    TInt            iPendingNotifications;

    TInt            iCompletedOkNotifications;

    TInt            iCanceledNotifications;

    TInt            iOverflowedNotifications;

    TInt            iNotVisibleNotifications;

    TInt            iOtherNotifications;

    };

CSurfaceStream::TGlobalNotification::TGlobalNotification():

iStatus(NULL),

iThreadId(0),

iPendingNotifications(0),

iCompletedOkNotifications(0),

iCanceledNotifications(0),

iOverflowedNotifications(0),

iNotVisibleNotifications(0),

iOtherNotifications(0)

    {

    }

void CSurfaceStream::TGlobalNotification::Reset()

    {

    iStatus = NULL;

    iThreadId = 0;

    iPendingNotifications = 0;

    iCompletedOkNotifications = 0;

    iCanceledNotifications = 0;

    iOverflowedNotifications = 0;

    iNotVisibleNotifications = 0;

    iOtherNotifications = 0;

    }

struct CSurfaceStream::TNewGlobalNotifications

    {

    TNewGlobalNotifications();

    TInt iNewAvailableIdx;

    TInt iNewDisplayedIdx;

    TInt iNewDisplayedXIdx;

    };

CSurfaceStream::TNewGlobalNotifications::TNewGlobalNotifications():

iNewAvailableIdx(KInvalidIndex),

iNewDisplayedIdx(KInvalidIndex),

iNewDisplayedXIdx(KInvalidIndex)

    {

    }

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

iLock(aLock)

    {

    iLock.Wait();

    }

CSurfaceStream::Guard::~Guard()

    {

    iLock.Signal();

    }

CSurfaceStream::CSurfaceStream():

	iSurfaceId(TSurfaceId::CreateNullId()),

	iBufferInfo(NULL),

	iProtected(EFalse),

	iNumberOfScreenAttachedAvailableNotif(0),

	iNumberOfScreenAttachedDisplayedNotif(0),

	iNumberOfScreenAttachedDisplayedXNotif(),

	iFlipState(EFlippedTargetNormal),

    iNewFlip(EFlipNotSet)

	{

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

			reinterpret_cast<TInt>(this);

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

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

	}

CSurfaceStream::ContentUpdatedParams::ContentUpdatedParams(TInt aBuffer,

                                                           TRequestStatus* aStatusDisplayed, TUint32* aTimeStamp,

                                                           TRequestStatus* aStatusDispXTimes, TInt* aDisplayedXTimes,

                                                           TRequestStatus* aStatusConsumed, const TRegion* aRegion,

                                                           TBool aImmediateAvailable, TInt32 aImmediateVisibility,

                                                           const TNewGlobalNotifications& aGlobalNotifications):

iBuffer(aBuffer),

iStatusDisplayed(aStatusDisplayed),

iTimeStamp(aTimeStamp),

iStatusDispXTimes(aStatusDispXTimes),

iDisplayedXTimes(aDisplayedXTimes),

iStatusConsumed(aStatusConsumed),

iRegion(aRegion),

iImmediateAvailable(aImmediateAvailable),

iImmediateVisibility(aImmediateVisibility),

iGlobalNotifications(aGlobalNotifications)

    {

    }

CSurfaceStream::~CSurfaceStream()

	{

	// Cancel any outstanding notifications

	CancelNotifications();

    iCallBacks.Close();

    iGlobalNotifications.Close();

    iBufferChunk.Close();

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

        {

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

        }

	iRefCountMutex.Close();

	iCallBacksMutex.Close();

	delete [] iBufferInfo;

	}

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

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aId);

	return self;

	}

void CSurfaceStream::ConstructL(const TSurfaceId& aId)

	{

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

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

    RSurfaceManager::TInfoBuf infoBuf;  

    SurfaceInfoL(aId, infoBuf);

	iInfo = infoBuf();

    COpenWfcStreamMap& stream = GetSingletonL();

	//Create array for TBufferInfo

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

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

		{

		TInt offset = 0;

	    switch(aId.Type())

	        {

	        case TSurfaceTypes::ESurfaceManagerSurface:

	            {

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

	                     i, offset));

	            break;

	            }

	        case TSurfaceId::EScreenSurface:

	            {

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

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

	            break;

	            }

	        default:

	            User::Leave(KErrNotSupported);

	        }

		iBufferInfo[i].iRefCount = 0;

		iBufferInfo[i].iOffset = offset;

		}

	}

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

    {

    COpenWfcStreamMap& stream = GetSingletonL();    

    switch(aId.Type())

        {

        case TSurfaceTypes::ESurfaceManagerSurface:

            {

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

                    reinterpret_cast<TInt>(this);

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

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

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

            iSurfaceId = aId;

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

            break;

            }

        case TSurfaceId::EScreenSurface:

            {

            // DSA surface only has one buffer

            aInfoBuf().iBuffers = 1;

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

            TInt width;

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

            TInt height;

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

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

            TInt bpp = 0;

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

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

            if (!pixelFormat)

                {

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

                if (bpp==12)

                    {

                    pixelFormat = EUidPixelFormatXRGB_4444;

                    }

                else if (bpp == 16)

                    {

                    pixelFormat = EUidPixelFormatRGB_565;

                    }

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

                    {

                    pixelFormat = EUidPixelFormatARGB_8888;

                    }

                else

                    {

                    User::Leave(KErrNotSupported);

                    }

                }

            aInfoBuf().iPixelFormat = pixelFormat;

#ifdef  SYMBIAN_ROTATION_MODE_CHANGES

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

#else

            TInt displayMode = 0;

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

#endif            

#if defined(SYMBIAN_ROTATION_MODE_CHANGES)

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

                {

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

                aInfoBuf().iSize.iWidth = height;

                aInfoBuf().iSize.iHeight = width;

                //"vertical" stride has already been fetched

                }

#elif defined(SYMBIAN_ROTATION_CHANGES)

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

                {

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

                aInfoBuf().iSize.iWidth = height;

                aInfoBuf().iSize.iHeight = width;

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

                }

#endif            

            TInt stride = displayMode;

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

            aInfoBuf().iStride = stride;             

            iSurfaceId = aId;

            break;

            }

        default:

            User::Leave(KErrNotSupported);

        } 

    }

COpenWfcStreamMap& CSurfaceStream::GetSingletonL()

	{

	return COpenWfcStreamMap::InstanceL();

	}

/**

	Helper to resolve handle to stream object

**/

/*static*/

CSurfaceStream* CSurfaceStream::FromHandle(SymbianStreamType aNativeStreamHandle)

	{

	if (aNativeStreamHandle)

		{

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

			{

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

			}

		}

	return NULL;

	}

/**

	Helper to resolve handle to stream object

**/

SymbianStreamType CSurfaceStream::ToHandle()

	{

	if (this)

		{

		return &iStreamProxySurfaceId;

		}

	else

		{

		return NULL;

		}

	}

/**	Returns internal surface ID.

 *

 * @return surface id asociated with this stream

 **/

const TSurfaceId& CSurfaceStream::SurfaceId()const

	{

	return iSurfaceId;

	}

/*!

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

 *

 */

 void CSurfaceStream::AddReference()

	 {

	 iRefCountMutex.Wait();

	 iRefCount++;

	 iRefCountMutex.Signal();

	 }

/*!

 * \internal

 *

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

 *

 */

TBool	CSurfaceStream::RemainingReference()

	{

	 iRefCountMutex.Wait();

	 TBool countZero=iRefCount==0;

	 iRefCountMutex.Signal();

	 return countZero;

	}

/*!

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

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

 *

 * All acquired read & write buffers must be released

 * before calling WFC_Native_Destroy.

 *

 */

void CSurfaceStream::ReleaseReference()

	{

	iRefCountMutex.Wait();

	--iRefCount;

	if (iRefCount < 1)

		{

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

		iRefCountMutex.Signal();

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

		}

	else

		{

		iRefCountMutex.Signal();

		}

	 }

/*!

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

 * all or some of the frame properties.

 *

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

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

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

 * parameter should be saved

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

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

 *                  the parameter is a negative number            

 * parameter should be saved

 * Passing a NULL pointer implies that particular

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

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

 * would only fetch width & height parameters.

 */

void CSurfaceStream::GetHeader(  khronos_int32_t* aWidth,

                           khronos_int32_t* aHeight,

                           khronos_int32_t* aStride,

                           SymOwfPixelFormat* aFormat,

                           khronos_int32_t* aPixelSize)

	 {

	 Guard g1(iRefCountMutex);

	 if (aWidth)

		 {

		 if (iFlipState == EFlippedTargetFlipped)

		     {

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

		     }

		 else

		     {

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

		     }

		 }

	 if (aHeight)

		 {

         if (iFlipState == EFlippedTargetFlipped)

             {

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

             }

         else

             {

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

             }

		 }

	 if (aStride)

		 {

         if (iFlipState == EFlippedTargetFlipped)

             {

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

             }

         else

             {

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

             }

		 }

	 if (aFormat)

		 {

		 *aFormat=iInfo.iPixelFormat;

		 }

	 if (aPixelSize)

		 {

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

		 }

	 }

/*!

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

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

 * WFC_INVALID_HANDLE if no buffer is available for reading.

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

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

 * that is.)

 *

 *

 * \return WFC_INVALID_HANDLE if no buffer is available or

 * handle to last committed buffer.

 *

 * An example sequence for 3 buffer stream where

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

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

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

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

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

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

 * "i" stands for WFC_INVALID_HANDLE:

 *

 * \code

 * Time:   0    5    10   15   20   25

 * Pframe: 0    1    2    0    1    ...

 * Cframe: ii00000111112222200000111...

 * \endcode

 */

SymbianStreamBuffer CSurfaceStream::AcquireReadBuffer()

	 {

	 SymbianStreamBuffer buffer = WFC_INVALID_HANDLE;

	 iRefCountMutex.Wait();

	 TInt index = GetReadBufferIndex();

     buffer = IndexToReadHandle(index);

     ++(iBufferInfo[index].iRefCount);

	 iRefCountMutex.Signal();

	 AddReference();

	 return buffer;

	 }

/*!

 * \brief Releases read buffer.

 *

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

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

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

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

 * by the producer)

 *

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

 * given stream.

 */

TInt CSurfaceStream::ReleaseReadBuffer(SymbianStreamBuffer aBuf)

	 {

	 TInt index = BufferHandleToIndex(aBuf);

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

		 {

		 return KErrBadHandle;

		 }

     iRefCountMutex.Wait();

      __ASSERT_DEBUG(iBufferInfo[index].iRefCount > 0, 

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

      --(iBufferInfo[index].iRefCount);

     iRefCountMutex.Signal();

     ReleaseReference();

     return KErrNone;

	 }

/*!

 * \brief Acquires write buffer for stream.

 *

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

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

 * invalid handle is returned.

 *

 *

 * \return Handle to a writable buffer

 */

SymbianStreamBuffer CSurfaceStream::AcquireWriteBuffer()

	 {

	 SymbianStreamBuffer   buffer = WFC_INVALID_HANDLE;

     iRefCountMutex.Wait();

     TInt index = GetWriteBufferIndex();

     //Writers are currently not blocked in single buffered,

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

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

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

       	{

        buffer = WFC_INVALID_HANDLE;

      	}

     else

       	{

        buffer = IndexToWriteHandle(index);

        ++(iBufferInfo[index].iRefCount);

        iAcquiredWriteBuffer = buffer;

       	}

    iRefCountMutex.Signal();

    if (buffer)

    	{

    	AddReference();

    	}

    return buffer;

	}

/*!

 * \brief Releases write buffer to stream.

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

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

 *

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

 * for given stream.

 */

void CSurfaceStream::ReleaseWriteBuffer(SymbianStreamBuffer aBuf)

	 {

	 TInt index = BufferHandleToIndex(aBuf);

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

		 {

		 return;

		 }

	 iRefCountMutex.Wait();

     __ASSERT_DEBUG(iBufferInfo[index].iRefCount > 0,

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

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

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

	 if (iAcquiredWriteBuffer != BUFFER_WRITE_UPDATE_OVERWRITE)

		 {

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

		 SetReadBufferIndex(index);

		 }

	 iAcquiredWriteBuffer = WFC_INVALID_HANDLE;

     --(iBufferInfo[index].iRefCount);

     if (iNewFlip != EFlipNotSet)

         {

         iFlipState = iNewFlip;

         iNewFlip = EFlipNotSet;

         }

	 iRefCountMutex.Signal();

	 NotifyObservers(ESOWF_EventComposed);

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

	 }

void CSurfaceStream::SetReadBufferIndex(TInt aIndex)

	{

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

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

	iReadBuffer = aIndex;

	}

TInt CSurfaceStream::GetReadBufferIndex()

	{

	return iReadBuffer;

	}

TInt CSurfaceStream::GetWriteBufferIndex()

	{

	return (iReadBuffer+1)%iInfo.iBuffers;

	}

/*! \brief Returns pointer to pixel buffer.

 *

 * \param buffer Handle of buffer

 */

void* CSurfaceStream::GetBufferPtrL(SymbianStreamBuffer aBuffer)

	 {

     TInt bufferIndex = BufferHandleToIndex(aBuffer);  

     Guard g1(iRefCountMutex);

     __ASSERT_DEBUG(iBufferInfo[bufferIndex].iRefCount > 0,

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

     switch (SurfaceId().Type())

         {

         case TSurfaceTypes::ESurfaceManagerSurface:

             {                         

             if (iBufferChunk.Handle() == 0)

                 {

                 RChunk threadChunk;

                 RSurfaceManager sm;

                 sm.Open();

                 TInt err = sm.MapSurface(iSurfaceId, threadChunk);

                 sm.Close();

                 CleanupClosePushL(threadChunk);

				 RChunk duplicateChunk;

				 duplicateChunk.SetHandle(threadChunk.Handle());

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

                 iBufferChunk.SetHandle(duplicateChunk.Handle());

                 CleanupStack::PopAndDestroy(&threadChunk);

                 }

             break;

             }

	     case TSurfaceId::EScreenSurface:

	         {

	         if (iBufferChunk.Handle() == 0)

	             {

	             TInt val = 0;

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

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

	             RChunk threadChunk;

				 CleanupClosePushL(threadChunk);

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

				 RChunk duplicateChunk;

				 duplicateChunk.SetHandle(threadChunk.Handle());

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

	             iBufferChunk.SetHandle(duplicateChunk.Handle());

	             CleanupStack::PopAndDestroy(&threadChunk);

	             }

	         break;

	         }

	     default:

	         User::Leave(KErrNotSupported);

	     }

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

     return static_cast<void*>(pBufferStart);	 

	 }

void CSurfaceStream::SetProtectionFlag(TBool aFlag)

	{

	iRefCountMutex.Wait();

	if (aFlag!=iProtected)

		{

		iProtected=aFlag;

		iRefCountMutex.Signal();

		if (aFlag)

			{

			AddReference();

			}

		else

			{

			ReleaseReference();

			}

		}

	else

		{

		iRefCountMutex.Signal();

		}

	}

TInt CSurfaceStream::BytesPerPixel(TUidPixelFormat aPixelFormat)

	{

	switch (aPixelFormat)

		{

		case EUidPixelFormatXRGB_8888:

		case EUidPixelFormatARGB_8888:

		case EUidPixelFormatBGRX_8888:

		case EUidPixelFormatXBGR_8888:

		case EUidPixelFormatBGRA_8888:

		case EUidPixelFormatABGR_8888:	

		case EUidPixelFormatABGR_8888_PRE:

		case EUidPixelFormatARGB_8888_PRE:

		case EUidPixelFormatBGRA_8888_PRE:

		case EUidPixelFormatARGB_2101010:

		case EUidPixelFormatABGR_2101010:

			return 4;

		case EUidPixelFormatBGR_888:

		case EUidPixelFormatRGB_888:

			return 3;

		case EUidPixelFormatXRGB_4444:

		case EUidPixelFormatARGB_4444:

		case EUidPixelFormatXBGR_4444:

		case EUidPixelFormatRGB_565:

		case EUidPixelFormatBGR_565:

		case EUidPixelFormatARGB_1555:

		case EUidPixelFormatXRGB_1555:

		case EUidPixelFormatARGB_8332:

		case EUidPixelFormatBGRX_5551:

		case EUidPixelFormatBGRA_5551:

		case EUidPixelFormatBGRA_4444:

		case EUidPixelFormatBGRX_4444:

		case EUidPixelFormatAP_88:

			return  2;

		case EUidPixelFormatRGB_332:

		case EUidPixelFormatBGR_332:

	    case EUidPixelFormatA_8:

	    case EUidPixelFormatL_8:

	        return  1;

		case EUidPixelFormatP_8:

			return -1;

	    case EUidPixelFormatP_4:

	    case EUidPixelFormatL_4:

	    	return -2;

	    case EUidPixelFormatL_2:

	    case EUidPixelFormatP_2:

	    	return -4;

	    case EUidPixelFormatL_1 :

            return -8;

		default:

			{

			return 0;

			}

		}

	}

SymbianStreamBuffer CSurfaceStream::IndexToReadHandle(TInt aIndex)

	{

	return static_cast<SymbianStreamBuffer>(aIndex + BUFFER_READ_HANDLE_BASE);

	}

SymbianStreamBuffer CSurfaceStream::IndexToWriteHandle(TInt aIndex)

	{

	return static_cast<SymbianStreamBuffer>(aIndex + BUFFER_WRITE_HANDLE_BASE);

	}

TInt CSurfaceStream::BufferHandleToIndex(SymbianStreamBuffer aBuff)

	{

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

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

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

	return retVal;

	}

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

    {

    if (aRequestStatus)

        {

        if (aGlobalIndexArray != KInvalidIndex)

            {

            TGlobalNotification& globalNotification = iGlobalNotifications[aGlobalIndexArray];

            --globalNotification.iPendingNotifications;

            switch (aStatus)

                {

                case KErrNone:

                    globalNotification.iCompletedOkNotifications++;

                    break;

                case KErrOverflow:

                    globalNotification.iOverflowedNotifications++;

                    break;

                case KErrCancel:

                    globalNotification.iCanceledNotifications++;

                    break;

                case KErrNotVisible:

                    globalNotification.iNotVisibleNotifications++;

                    break;

                default:

                    globalNotification.iOtherNotifications++;

                }

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

                    "iCompletedOkNotifications(%d)"

                    "iOverflowedNotifications(%d)"

                    "iCanceledNotifications(%d)"

                    "iNotVisibleNotifications(%d)"

                    "iOtherNotifications(%d)"

                    "requestStatus(%p)",

                    aGlobalIndexArray, 

                    globalNotification.iPendingNotifications, 

                    globalNotification.iCompletedOkNotifications, 

                    globalNotification.iOverflowedNotifications,

                    globalNotification.iCanceledNotifications,

                    globalNotification.iNotVisibleNotifications,

                    globalNotification.iOtherNotifications,

                    aStatus));

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

                {

                TInt status;

                if (globalNotification.iCompletedOkNotifications > 0)

                    {

                    status = KErrNone;

                    }

                else if (globalNotification.iOverflowedNotifications > 0)

                    {

                    status = KErrOverflow;

                    }

                else if (globalNotification.iNotVisibleNotifications > 0)

                    {

                    status = KErrNotVisible;

                    }

                else if (globalNotification.iCanceledNotifications > 0)

                    {

                    status = KErrCancel;

                    }

                else

                    {

                    status = KErrGeneral;

                    }

                RThread thread;

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

                    {

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

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

                    thread.RequestComplete(globalNotification.iStatus, status);

                    thread.Close();

                    iGlobalNotifications[aGlobalIndexArray].Reset();

                    }

                }

            }

        else

            {

            RThread thread;

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

                {

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

                        aRequestStatus, aThreadId, aStatus));

                thread.RequestComplete(aRequestStatus, aStatus);

                thread.Close();

                }

            }

        aRequestStatus = NULL;

        aThreadId = 0;

        }

    aGlobalIndexArray = KInvalidIndex;

    }

int  CSurfaceStream::AddObserver(SymbianStreamCallback aObserver, 

                                 TInt32 aEvent,

                                 TInt32 aScreenNumber,

                                 void* aData)

     {

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

         {

         // early exit if the parameters are invalid

         return KErrArgument;

         }

     TInt  errRet = KErrNone;

     TCallBackEntry newEntry;

     Guard g2(iCallBacksMutex);

     Guard g1(iRefCountMutex);

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

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

     TInt  idx = iCallBacks.Count();

     while(idx--)

         {

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

             {

             switch (aEvent)

                 {

                 case ESOWF_EventAvailable:

                 case ESOWF_EventDisplayed:

                 case ESOWF_EventDisplayedX:

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

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

                         {

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

                         return KErrOverflow;

                         }

                     break;

                 case ESOWF_EventComposed:

                 case ESOWF_EventUpdated:

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

                         {

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

                         return KErrOverflow;

                         }

                     break;

                 default:

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

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

                     iCallBacks[idx].Reset();

                     break;

                 }

             }

         }

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

    newEntry.iCallBackFunction = aObserver;

    newEntry.iEventMask = aEvent;

    newEntry.iScreenNumber = aScreenNumber;

    TInt trapErr;

    switch (aEvent)

        {

        case ESOWF_EventUpdated:

        case ESOWF_EventComposed:

            newEntry.iCallBackClientParam = aData;

            break;

        case ESOWF_EventAvailable:

            {

            TNotificationAvailable* available = NULL;

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

            if (trapErr != KErrNone)

                {

                return trapErr;

                }

            ResetCallBackData(available, aEvent);

            available->iSerialNumber = KInitialContextSerialNumber;

            newEntry.iCallBackClientParam = available;

            }

            break;

        case ESOWF_EventDisplayed:

            {

            TNotificationDisplayed* displayed = NULL;

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

            if (trapErr != KErrNone)

                {