// 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);
    }