// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 //

 // Permission is hereby granted, free of charge, to any person obtaining a

 // copy of this software and/or associated documentation files (the

 // "Materials"), to deal in the Materials without restriction, including

 // without limitation the rights to use, copy, modify, merge, publish,

 // distribute, sublicense, and/or sell copies of the Materials, and to

 // permit persons to whom the Materials are furnished to do so, subject to

 // the following conditions:

 //

 // The above copyright notice and this permission notice shall be included

 // in all copies or substantial portions of the Materials.

 //

 // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 // MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

 //

 // Description:

 //

 /**

  @file

 */

 #include <e32std.h>

 #include <imageconversion.h>

 #include <graphics/symbianstream.h>

 #include "streamutility.h"

 #define WFC_INVALID_HANDLE NULL

 CStreamUtility::CStreamUtility()

 	{

 	}

 CStreamUtility* CStreamUtility::NewL()

 	{

 	CStreamUtility* utility = new (ELeave)CStreamUtility();

 	CleanupStack::PushL(utility);

 	utility->ConstructL();

 	CleanupStack::Pop(utility);

 	return utility;

 	}

 void CStreamUtility::ConstructL()

 	{

 	TInt r = iManager.Open();

 	if (r != KErrNone)

 		{

 		LOG(("Surface manager failed to open: %d", r));

 		User::Leave(r);

 		}

 	}

 CStreamUtility::~CStreamUtility()

 	{

 	DestroyAll();

 	iStreams.Close();

 	iManager.Close();

 	}

 TBool CStreamUtility::DestroyAll()

 	{

 	TInt err = 	KErrNone;

 	TInt jj = iStreams.Count() - 1;

 	if (jj<0)

 		return EFalse;

 	for (; jj >= 0; jj--)

 		{

         //The following lines are just to get the surface ID for verification

 		SymbianStreamBuffer bufferHandle;

 		User::LeaveIfError(SymbianStreamAcquireReadBuffer(iStreams[jj], &bufferHandle));

 		long bufferIndex;

 		const TSurfaceId* pSurfaceId = NULL;

 		User::LeaveIfError(SymbianStreamGetBufferId(iStreams[jj],bufferHandle,&bufferIndex,&pSurfaceId));

         User::LeaveIfError(SymbianStreamReleaseReadBuffer(iStreams[jj], bufferHandle));

         const TSurfaceId surfaceId = *pSurfaceId;   //Need to copy my reference to the ID.

         //Actually release the stream

         SymbianStreamRemoveReference(iStreams[jj]);

         //Verify the stream is now not accessible

         TInt offset;

 		err = iManager.GetBufferOffset(surfaceId,0,offset);

 		if (err==KErrNone)

 			{

 			LOG(("Closing stream via DestoryAll did not destroy surface!"));

 			}

 		}

 	iStreams.Reset();

 	return ETrue;

 	}

 /***************************************

  * The aim of the RHeapStreamArray is to locally switch in the specified heap for any array operation

  ***************************************/

 CStreamUtility::RHeapStreamArray::RHeapStreamArray(RHeapStreamArray* aUseExternalArray)

 	:	iUseArray(aUseExternalArray?aUseExternalArray->iUseArray:&this->iLocalArray),

 	iExternalHeapRef(aUseExternalArray?aUseExternalArray->iExternalHeapRef:User::Heap())

 	{

 	}

 /************************************

  * The following methods have been used by the streamutility... some require the heap wrapping, and some don't

  * I actually need three different strategies (count em) for 7 methods...

  * Some methods only read the existing objects, so don't need a heap swap at all

  * Leaving methods have to use PopAndDestroy strategy to restore the heap on leaving or success

  * Non-leaving methods must not call PushL, so directly make SwitchHeap calls!

  ************************************/

 /// PopAndDestroy method to restore the heap

 /*static*/ void	CStreamUtility::RHeapStreamArray::PopHeap(void* aHeapPtr)

 	{

 	RHeap* heapPtr=(RHeap*)aHeapPtr;

 	User::SwitchHeap(heapPtr);

 	}

 SymbianStreamType& CStreamUtility::RHeapStreamArray::operator[](TUint aIndex)

 	{

 	return iUseArray->operator[](aIndex);

 	}

 /// Close only closes the local array, while Reset resets the active array (may be external)

 void CStreamUtility::RHeapStreamArray::Close()

 	{

 	iLocalArray.Close();

 	}

 TInt CStreamUtility::RHeapStreamArray::Count() const

 	{

 	return iUseArray->Count();

 	}

 /// Close only closes the local array, while Reset resets the active array (may be external)

 inline void CStreamUtility::RHeapStreamArray::Reset()

 	{

 	iUseArray->Reset();

 	}

 void CStreamUtility::RHeapStreamArray::AppendL(const SymbianStreamType &anEntry)

 	{

 	iUseArray->AppendL(anEntry);

 	}

 TInt CStreamUtility::RHeapStreamArray::Find(const SymbianStreamType &anEntry) const

 	{

 	return iUseArray->Find(anEntry);

 	}

 void CStreamUtility::RHeapStreamArray::Remove(TInt anIndex)

 	{

 	iUseArray->Remove(anIndex);

 	}

 /**

 Cleanup stack helper object, holding references to both utility and stream, so

 that the standard Close() semantics can be used.

 */

 class TStreamCleanup

 	{

 public:

 	TStreamCleanup(CStreamUtility& aUtility, SymbianStreamType& aStream)

 		: iUtility(aUtility), iStream(aStream)

 		{}

 	void Close()

 		{

 		// Removes the stream from the list of streams to clean up, and closes

 		// the stream reference.

 		iUtility.DestroyStream(iStream);

 		}

 private:

 	CStreamUtility& iUtility;

 	SymbianStreamType& iStream;

 	};

 /**

 Get the size of a stream.

 @param  aStream The stream to get the size for.

 @return The size in pixels, or empty on failure.

 */

 TSize CStreamUtility::StreamSize(const SymbianStreamType aStream)

 	{

 	khronos_int32_t width;

 	khronos_int32_t height;

 	khronos_int32_t stride;

 	khronos_int32_t format;

 	khronos_int32_t pixelSize;

 	SymbianStreamGetHeader(aStream, &width, &height, &stride, &format, &pixelSize);

 	TSize size = TSize(static_cast<TInt>(width), static_cast<TInt>(height));

 	return size;

 	}

 /**

 Create a stream using the surface manager.

 Stores the ID for tear down, as well as returning it.

 @param aSize            Dimensions of the stream.

 @param aPixelFormat	    UID of the pixel format.

 @param aStride	        Stride value for the stream (usually bytes per pixel * width)

 @param aReturnSurface   Returns TSurfaceId wrapped by the stream

 @param aContiguous      Contiguous flag for creating surfaces

 @param aBuffers         Number of buffers

 @leave May leave due to lack of memory.

 @return New stream's ID.

 */

 SymbianStreamType CStreamUtility::CreateStreamL(const TSize& aSize, TUidPixelFormat aPixelFormat, 

                                             TInt aStride, TSurfaceId& aReturnSurface, 

                                             TBool aContiguous, TInt aBuffers)

 	{

 	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

 	RSurfaceManager::TSurfaceCreationAttributes& b = bf();

 	if (aStride<aSize.iWidth*BytesPerPixelL(aPixelFormat))

 	    {

 	    User::Leave(KErrOverflow);

 	    }

 	b.iSize.iWidth = aSize.iWidth;

 	b.iSize.iHeight = aSize.iHeight;

 	b.iBuffers = aBuffers;				// number of buffers in the surface

 	b.iPixelFormat = aPixelFormat;

 	b.iStride = aStride;		// Number of bytes between start of one line and start of next

 	b.iOffsetToFirstBuffer = 0;	// way of reserving space before the surface pixel data

 	b.iAlignment = 4;			// alignment, 1,2,4,8 byte aligned

 	b.iContiguous = !!aContiguous;

 	b.iMappable = ETrue;

 	aReturnSurface = TSurfaceId::CreateNullId();

 	User::LeaveIfError(iManager.CreateSurface(bf, aReturnSurface));

 	SymbianStreamType ns;

 	TInt err = SymbianStreamAcquire(&aReturnSurface, &ns);

     iManager.CloseSurface(aReturnSurface);		//The stream should now own the only reference

 	if (err != KErrNone)

 		{

 		User::Leave(err);	

 		}

 	iStreams.AppendL(ns);

 	return ns;

 	}

 /**

 Fill the given stream with a color.

 @param aStream	The stream to be filled.

 @param aColor	The color to fill it with.

 */

 void CStreamUtility::FillStreamL(SymbianStreamType aStream, const TRgb& aColor)

 	{

 	khronos_int32_t width;

 	khronos_int32_t height;

 	khronos_int32_t stride;

 	khronos_int32_t format;

 	khronos_int32_t pixelSize;

 	SymbianStreamGetHeader(aStream, &width, &height, &stride, &format, &pixelSize);

 	TUint32 color = 0;

 	TBool use16 = EFalse;

 	if (height<0 || width<0 || stride<0)

 		{

 		User::Leave(KErrCorrupt);

 		}

 	if (height==0 || width==0 || stride==0)

 		{

 		User::Leave(KErrNotReady);

 		}

 	switch (format)

 		{

 		case EUidPixelFormatXRGB_8888:

 			{

 			color = aColor.Color16MU();

 			break;

 			}

 		case EUidPixelFormatARGB_8888:

 			{

 			color = aColor.Color16MA();

 			break;

 			}

 		case EUidPixelFormatARGB_8888_PRE:

 			{

 			color = aColor.Color16MAP();

 			break;

 			}

 		case EUidPixelFormatXRGB_4444:

 		case EUidPixelFormatARGB_4444:

 			{

 			color = aColor.Color4K();

 			use16 = ETrue;

 			break;

 			}

 		case EUidPixelFormatRGB_565:

 			{

 			color = aColor.Color64K();

 			use16 = ETrue;

 			break;

 			}

 		default:

 			{

 			User::Leave(KErrNotSupported);

 			break;

 			}

 		}

     SymbianStreamBuffer bufferHandle;

     User::LeaveIfError(SymbianStreamAcquireWriteBuffer(aStream, &bufferHandle));

     long bufferIndex;

     const TSurfaceId* surfaceId = NULL;

     User::LeaveIfError(SymbianStreamGetBufferId(aStream,bufferHandle,&bufferIndex,&surfaceId));

 	RChunk chunk;

 	User::LeaveIfError(iManager.MapSurface(*surfaceId, chunk));

 	CleanupClosePushL(chunk);

 	TInt offsetToFirstBuffer;

 	User::LeaveIfError(iManager.GetBufferOffset(*surfaceId, 0, offsetToFirstBuffer));

 	TUint8* streamPtr = chunk.Base() + offsetToFirstBuffer;

 	TUint8* linePtr = streamPtr;

 	if (use16)

 		{

 		if ( width*2>stride)

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint16* ptr = reinterpret_cast<TUint16*>(streamPtr);

 		// Fill first line

 		for (TInt xx = 0; xx < width; xx++)

 			{

 			ptr[xx] = (TUint16)color;

 			}

 		}

 	else

 		{

 		if ( width*4>stride)

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint32* ptr = reinterpret_cast<TUint32*>(streamPtr);

 		// Fill first line

 		for (TInt xx = 0; xx < width; xx++)

 			{

 			ptr[xx] = color;

 			}

 		}

 	// Now copy that to the other lines

 	for (TInt yy = 1; yy < height; yy++)

 		{

 		linePtr += stride;

 		Mem::Copy(linePtr, streamPtr, width * BytesPerPixelL(aStream));

 		}

 	User::LeaveIfError(SymbianStreamReleaseWriteBuffer(aStream, bufferHandle));

 	CleanupStack::PopAndDestroy(/* chunk */);

 	}

 /**

 Destroy a stream.

 As well as destroying the stream, it is removed from the set held for

 destruction during tear down.

 @param aStream	The stream to be destroyed.

 */

 void CStreamUtility::DestroyStream(SymbianStreamType aStream)

 	{

 	TInt index = iStreams.Find(aStream);

 	if (index != KErrNotFound)

 		{

 		iStreams.Remove(index);

 		}

 	SymbianStreamRemoveReference(aStream);

 	}

 /**

 A helper function that returns the bytes per pixel for a given pixel format uid

 @param      aPixelFormat Pixel format UID to convert

 @return     The bytes per pixel

 */

 TInt CStreamUtility::BytesPerPixelL(TUidPixelFormat aPixelFormat)

     {

     TInt bytesPerPixel = 0;

     switch (aPixelFormat)

         {

         case EUidPixelFormatXRGB_8888:

         case EUidPixelFormatARGB_8888:

         case EUidPixelFormatARGB_8888_PRE:

             {

             bytesPerPixel = 4;

             break;

             }

         case EUidPixelFormatXRGB_4444:

         case EUidPixelFormatARGB_4444:

         case EUidPixelFormatRGB_565:

             {

             bytesPerPixel = 2;

             break;

             }

         default:

             {

             User::Leave(KErrNotSupported);

             break;

             }

         }

     return bytesPerPixel;

     }

 /**

 A helper function that returns the bytes per pixel for a given stream

 @param      aStream The stream which is checked

 @return     The bytes per pixel

 */

 TInt CStreamUtility::BytesPerPixelL(const SymbianStreamType aStream)

     {

     khronos_int32_t width;

     khronos_int32_t height;

     khronos_int32_t stride;

     khronos_int32_t format;

     khronos_int32_t pixelSize;

     SymbianStreamGetHeader(aStream, &width, &height, &stride, &format, &pixelSize);

     return static_cast<TInt>(pixelSize);

     }