// 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