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