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

//

#include "screencaptureutil.h"

#include <e32std.h>

#include <e32base.h>

#include "panic.h"

#include <fbs.h>

#include <graphics/wsgraphicscontext.h>

#include <graphics/wsdisplaycontrol.h>

#include <graphics/wsscene.h>

#include <graphics/wsdisplaymapping.h>

//#include <graphics/testscreencapture.h>

//#include <graphics/wsscreendeviceutils.h>

#include <graphics/wsscreendevice.h>

CScreenCaptureUtil* CScreenCaptureUtil::NewL(CWsRenderStage* aOwner)

	{

	CScreenCaptureUtil * util = new(ELeave) CScreenCaptureUtil;

	CleanupStack::PushL(util);

	util->ConstructL(aOwner);

	CleanupStack::Pop(util);

	return util;

	}

void CScreenCaptureUtil::ConstructL(CWsRenderStage* aOwner)

	{

	// initialise the references to the interfaces of interest

	iScene = aOwner->ObjectInterface<MWsScene>();

	STD_ASSERT_ALWAYS(iScene, EPluginPanicSceneMissing);

	iScreenDevice = aOwner->ObjectInterface<MWsScreenDevice>();

	STD_ASSERT_ALWAYS(iScreenDevice, EPluginPanicSceneMissing);

	iDisplayMapping = aOwner->ObjectInterface<MWsDisplayMapping>();

	// create the local surface

	User::LeaveIfError(iSurfaceManager.Open());

	User::LeaveIfError(iSurfaceUpdateSession.Connect());

	}

CScreenCaptureUtil::CScreenCaptureUtil()

	{

	}

CScreenCaptureUtil::~CScreenCaptureUtil()

	{

	iScene->UnregisterSurface(iLocalSurface);

	iSurfaceManager.CloseSurface(iLocalSurface);

	iSurfaceManager.Close();

	iSurfaceUpdateSession.Close();

	}

void CScreenCaptureUtil::ComposeScreenL(TInt aHandle)

	{

	TInt ret = KErrNone;

	//Let's duplicate the bitmap

	CFbsBitmap* bitmap=new(ELeave) CFbsBitmap();

	CleanupStack::PushL(bitmap);

	TInt r = bitmap->Duplicate(aHandle);

	if (r == KErrNoMemory)

		{

		User::Leave(KErrNoMemory);

		}

	ret = KErrBadHandle;

	if (r == KErrNone)

		{

		CreateLocalSurfaceL();

		// check that the bitmap format is matching our requirements

		if (VerifyBitmapFormatL(*bitmap))

		    {

	        ret = iScene->RegisterSurface(iLocalSurface);

	        if (ret == KErrNone)

	            {

	            TRequestStatus cRs = KErrNone;

	            iScene->ComposePendingScene(iLocalSurface, &cRs);

	            User::WaitForRequest(cRs);

	            ret = CopySurfaceToBitmapL(*bitmap);

	            }

			}

		else

			{

			// we accept only matching bitmap formats

			ret = KErrArgument;

			}

		}

	CleanupStack::PopAndDestroy(bitmap);

	}

/*

void CScreenCaptureUtil::TranslateExtentL(const TWsScsComposeScreenCommand& aMessage)

	{

	TPoint srcTopLeft(aMessage.iParameter.iExtent.iTl.iX, aMessage.iParameter.iExtent.iTl.iY);

	TPoint srcBottomRight(aMessage.iParameter.iExtent.iBr.iX, aMessage.iParameter.iExtent.iBr.iY);

	TRect rectSrc(srcTopLeft, srcBottomRight);

	TRect rectRes;

	TInt ret = iDisplayMapping->MapCoordinates(EApplicationSpace, rectSrc, ECompositionSpace, rectRes);

	aUtils.ReplyBuf(&rectRes, sizeof(TRect));

	aUtils.SetReply(ret);

	}

*/

TSurfaceId CScreenCaptureUtil::CreateSurfaceL(const TSize& aSize, TUidPixelFormat aPixelFormat, TInt aStride)

	{

	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

	RSurfaceManager::TSurfaceCreationAttributes& b = bf();

	b.iSize.iWidth = aSize.iWidth;

	b.iSize.iHeight = aSize.iHeight;

	b.iBuffers = 1;				// 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=EFalse;

	b.iMappable = ETrue;

	TSurfaceId surface = TSurfaceId::CreateNullId();

	User::LeaveIfError(iSurfaceManager.CreateSurface(bf, surface));

	return surface;

	}

void CScreenCaptureUtil::CreateLocalSurfaceL()

	{

	TSize surfaceSize;

	GetCompositionAreaSize(surfaceSize);

	if (!iLocalSurface.IsNull())

		{

        RSurfaceManager::TInfoBuf infoBuf;

    	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

        if ((KErrNone != iSurfaceManager.SurfaceInfo(iLocalSurface, infoBuf)) || 

        	(info.iSize != surfaceSize))

            {

            iScene->UnregisterSurface(iLocalSurface);

    		iSurfaceManager.CloseSurface(iLocalSurface);

    		iLocalSurface = TSurfaceId::CreateNullId();

            }

		}

	if (iLocalSurface.IsNull())

		{

		iLocalSurface = CreateSurfaceL(surfaceSize, KSurfacePixelFormat, KSurfaceBytesPerPixel*surfaceSize.iWidth);

		}

	}

TBool CScreenCaptureUtil::VerifyBitmapFormatL(const CFbsBitmap& aBitmap)

	{

  RSurfaceManager::TInfoBuf infoBuf;

	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

  User::LeaveIfError(iSurfaceManager.SurfaceInfo(iLocalSurface, infoBuf));

	return ((info.iSize == aBitmap.SizeInPixels()) && (EColor16MU == aBitmap.DisplayMode()));

	}

void CScreenCaptureUtil::GetCompositionAreaSize(TSize& aSize) const

	{

	TSize uiSize;

	uiSize = iScreenDevice->SizeInPixels();

	TRect uiRect(TPoint(0,0), uiSize);

	TRect compositionRect;

	iDisplayMapping->MapCoordinates(EFullScreenSpace, uiRect, ECompositionSpace, compositionRect);

	aSize = compositionRect.Size();

	}

TInt CScreenCaptureUtil::CopySurfaceToBitmapL(CFbsBitmap& aCopyToBitmap)

	{

	RSurfaceManager::TInfoBuf infoBuf;

	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

	User::LeaveIfError(iSurfaceManager.SurfaceInfo(iLocalSurface, infoBuf));

	TInt bytesPerPixel=0;

	TDisplayMode	bitmapMode = ENone;

	switch (info.iPixelFormat)

		{

		case EUidPixelFormatXRGB_8888:

			{

			bitmapMode = EColor16MU;

			bytesPerPixel = 4;

			break;

			}

		default:

			{

			return KErrCorrupt;

			}

		}

	if ((aCopyToBitmap.SizeInPixels() != info.iSize) || (aCopyToBitmap.DisplayMode() != bitmapMode))

		{

		return KErrCorrupt;

		}

	RChunk chunk;

	CleanupClosePushL(chunk);

	User::LeaveIfError(iSurfaceManager.MapSurface(iLocalSurface, chunk));

	TUint8* surfacePtr = chunk.Base();

	TUint8* bitmapPtr = (TUint8*)aCopyToBitmap.DataAddress();

	TInt copyBytes=info.iSize.iWidth*bytesPerPixel;

	for (TInt y=0; y<info.iSize.iHeight; y++)

		{

		Mem::Copy(bitmapPtr,surfacePtr,copyBytes);

		surfacePtr += info.iStride;

		bitmapPtr += aCopyToBitmap.DataStride();

		}

	CleanupStack::PopAndDestroy(&chunk);

	return KErrNone;

	}