// Copyright (c) 2002-2010 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 <mmf/common/mmfstandardcustomcommands.h>  

#include <mmf/common/mmfdrmcustomcommands.h>  

#include <mmf/common/mmfvideo.h>

#include <mmf/server/mmfdes.h>

#include <mmf/server/mmffile.h>

#include "mmfvideocallback.h"

#include "VideoPlayerBody.h"

#include "mmfclientvideocommon.h"

#include "mmfclientutility.h"

#include "mediaclientvideotrace.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/common/mmfvideoenums.h>

#endif

#ifdef SYMBIAN_BUILD_GCE

#include <videoplayer2.h>

#include <surfaceeventhandler.h>

#endif

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

#include <mmf/common/mmfpaniccodes.h>

#include "mmfsubtitleutility.h"

#endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

using namespace ContentAccess;

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

#ifdef _DEBUG

void VPUDebugPanicOrLeaveL(TInt aVPUPanicCode, TInt aLeaveCode)

	{

	_LIT(KMMFVideoPlayerUtilityPanicCategory, "MMFVideoPlayUtil");

	User::Panic(KMMFVideoPlayerUtilityPanicCategory, aVPUPanicCode);

	User::Leave(aLeaveCode); // added for leavescan

	}

#else

void VPUDebugPanicOrLeaveL(TInt /*aVPUPanicCode*/, TInt aLeaveCode)

	{

	User::Leave(aLeaveCode);

	}

#endif //_DEBUG

#endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

CVideoPlayerUtility::CBody* CVideoPlayerUtility::CBody::NewL(CVideoPlayerUtility* aParent,

															 MVideoPlayerUtilityObserver& aObserver,

															 TInt aPriority,

															 TInt aPref,

															 RWsSession& aWs,

															 CWsScreenDevice& aScreenDevice,

															 RWindowBase& aWindow,

															 const TRect& aScreenRect,

															 const TRect& aClipRect)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::NewL (CVPU1)++");

	CBody* self = new(ELeave) CBody(aParent, aObserver, aScreenDevice.GetScreenNumber(), aPriority, aPref);

	CleanupStack::PushL(self);

	self->ConstructL(aWs, aScreenDevice, aWindow, aScreenRect, aClipRect);

	CleanupStack::Pop();

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::NewL (CVPU1)--");

	return self;

	}

#ifdef SYMBIAN_BUILD_GCE

CVideoPlayerUtility::CBody* CVideoPlayerUtility::CBody::NewL(CVideoPlayerUtility2* aParent,

															 MVideoPlayerUtilityObserver& aObserver,

															 TInt aPriority,

															 TInt aPref)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::NewL (CVPU2)++");

	CBody* self = new(ELeave) CBody(aParent, aObserver, aPriority, aPref);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::NewL (CVPU2)--");

	return self;

	}

#endif // SYMBIAN_BUILD_GCE

CVideoPlayerUtility::CBody::~CBody()

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::~CBody++");

	Close();

	delete iControllerImplementationInformation;

	delete iDirectScreenAccess;

	delete iFindAndOpenController;

	delete iControllerEventMonitor;

	delete iFrameCallback;

	delete iAsyncCallback;

	delete iMimeType;

	delete iFrameBitmap;

	if (iFbsSessionConnected)

		iFbsSession.Disconnect();

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::~CBody--");

	}

void CVideoPlayerUtility::CBody::Close()

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::Close++");

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

	DisableSubtitles();

#endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

	if (iAsyncCallback)

		iAsyncCallback->Cancel();

	if (iFrameCallback)

		iFrameCallback->Cancel();

	if (iFindAndOpenController)

		iFindAndOpenController->Close();

	if (iControllerEventMonitor)

		iControllerEventMonitor->Cancel();

	if(iControllerImplementationInformation)

		{

		delete iControllerImplementationInformation;

		iControllerImplementationInformation = NULL;

		}

#ifdef SYMBIAN_BUILD_GCE

	iActiveDisplays.ResetAndDestroy();

	iSurfaceId = TSurfaceId::CreateNullId();

#endif

	iController.Close();	

	iControllerUid = KNullUid;

	iControllerOpen = EFalse;

	iDirectScreenAccessAbort = EFalse;

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::Close--");

	}

CVideoPlayerUtility::CBody::CBody(CVideoPlayerUtility* aParent,

								  MVideoPlayerUtilityObserver& aObserver,

								  TInt aScreenNumber,

								  TInt aPriority,

								  TInt aPref) : 

	iVideoControllerCustomCommands(iController),

	iVideoPlayControllerCustomCommands(iController),

	iAudioPlayDeviceCustomCommands(iController),

	iAudioRecordDeviceCustomCommands(iController),

	iVideoDRMExtCustomCommands(iController),

	iDRMCustomCommands(iController),

	iVideoPlayControllerExtCustomCommands(iController),	

	iNotificationRegistrationCommands(iController),

#ifdef SYMBIAN_BUILD_GCE

	iVideoPlaySurfaceSupportCustomCommands(iController),

#endif

	iArnEventHolder(KNullUid),

	iVideoSetInitScreenCustomCommands(iController),

	iObserver(aObserver),

	iState(EStopped),

	iParent(aParent),

	iScreenNumber(aScreenNumber)

#ifdef SYMBIAN_BUILD_GCE

	,iGlobalScaleWidth(100.0f),

	iGlobalScaleHeight(100.0f),

	iGlobalAutoScaleType(EAutoScaleBestFit),  // Really need some platform specific way of defining this. Not everyone will want it.

	iGlobalHorizPos(EHorizontalAlignCenter),

	iGlobalVertPos(EVerticalAlignCenter)

#endif

	{

	iPrioritySettings.iPriority = aPriority;

	iPrioritySettings.iPref = aPref;

	}

#ifdef SYMBIAN_BUILD_GCE

CVideoPlayerUtility::CBody::CBody(CVideoPlayerUtility2* aParent,

				MVideoPlayerUtilityObserver& aObserver,

				TInt aPriority,

				TInt aPref) : 

	iVideoControllerCustomCommands(iController),

	iVideoPlayControllerCustomCommands(iController),

	iAudioPlayDeviceCustomCommands(iController),

	iAudioRecordDeviceCustomCommands(iController),

	iVideoDRMExtCustomCommands(iController),

	iDRMCustomCommands(iController),

	iVideoPlayControllerExtCustomCommands(iController),

	iNotificationRegistrationCommands(iController),

	iVideoPlaySurfaceSupportCustomCommands(iController),

	iArnEventHolder(KNullUid),

	iVideoSetInitScreenCustomCommands(iController),

	iObserver(aObserver),

	iState(EStopped),

	iParent(aParent),

	iUsingVPU2(ETrue),

	iGlobalScaleWidth(100.0f),

	iGlobalScaleHeight(100.0f),

	iGlobalHorizPos(EHorizontalAlignCenter),

	iGlobalVertPos(EVerticalAlignCenter)

	{

	iPrioritySettings.iPriority = aPriority;

	iPrioritySettings.iPref = aPref;

	}

void CVideoPlayerUtility::CBody::ConstructL()

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::ConstructL1++");

	CommonConstructL();

	iFindAndOpenController = CMMFFindAndOpenController::NewL(*this);

	iFindAndOpenController->SetSurfaceMode(iUsingVPU2, &iVideoPlaySurfaceSupportCustomCommands);

	iFindAndOpenController->Configure(KUidMediaTypeVideo, iPrioritySettings, CMMFPluginSelectionParameters::EAllowOtherMediaIds);

	iFindAndOpenController->ConfigureController(iController, *iControllerEventMonitor, CMMFFindAndOpenController::EPlayback);

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::ConstructL1--");

	}

#endif // SYMBIAN_BUILD_GCE

void CVideoPlayerUtility::CBody::ConstructL(RWsSession& aWs,

						CWsScreenDevice& aScreenDevice,

						RWindowBase& aWindow,

						const TRect& aWindowRect,

						const TRect& aClipRect)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::ConstructL2++");

	CommonConstructL();

	SetDisplayWindowL(aWs, aScreenDevice, aWindow, aWindowRect, aClipRect);

	iFindAndOpenController = CMMFFindAndOpenController::NewL(*this);

#ifdef SYMBIAN_BUILD_GCE	

	iFindAndOpenController->SetSurfaceMode(iUsingVPU2, &iVideoPlaySurfaceSupportCustomCommands);

	// If we open a controller with surface support we may render to surfaces.  We need to store these

	// so we can add the display as a surface rendering target.

	iWs = &aWs;

	iDisplayId = aScreenDevice.GetScreenNumber();

	iWindow = &aWindow;

	iWindowRect = aWindowRect;

	iClipRect = aClipRect;	

#endif

	iFindAndOpenController->Configure(KUidMediaTypeVideo, iPrioritySettings, CMMFPluginSelectionParameters::EAllowOtherMediaIds);

	iFindAndOpenController->ConfigureController(iController, *iControllerEventMonitor, CMMFFindAndOpenController::EPlayback);

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::ConstructL2--");

	}

void CVideoPlayerUtility::CBody::CommonConstructL()

	{

	iControllerEventMonitor = CMMFControllerEventMonitor::NewL(*this, iController);

	iMimeType = HBufC8::NewL(KMaxMimeTypeLength);

	iAsyncCallback = new (ELeave) CMMFVideoPlayerCallback(iObserver);

	iFrameCallback = new (ELeave) CMMFVideoPlayerCallback(iObserver);

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

	iFbsSessionConnected = ETrue;

	}

void CVideoPlayerUtility::CBody::Reset() 

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::Reset++");

	Close();

	// reset all state variables

	iEventOpenReceived = EFalse;

	iCallbackOpenReceived = EFalse;

	iOpenError = KErrNone;

#ifdef SYMBIAN_BUILD_GCE

	iGraphicsSurfaceSupported = EFalse;

#endif

	iControllerUid = KNullUid;

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::Reset--");

	}

void CVideoPlayerUtility::CBody::SetAndUpdateWindow()

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetAndUpdateWindow++");

	if (iOpenError == KErrNone)	

		{

		// Set the display window and update display region if the controller doesn't support graphics surface. 		

		iOpenError = iVideoPlayControllerCustomCommands.SetDisplayWindow(iWindowRect, iClipRect);

		}

	if (iOpenError == KErrNone && iDirectScreenAccess && iDirectScreenAccess->DrawingRegion())

		{

		iOpenError = iVideoPlayControllerCustomCommands.UpdateDisplayRegion(*iDirectScreenAccess->DrawingRegion());

		}

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetAndUpdateWindow--");

	}

void CVideoPlayerUtility::CBody::MfaocComplete(		

	TInt& aError, 

	RMMFController*	/*aController*/,

	TUid aControllerUid, 

	TMMFMessageDestination* /*aSourceHandle*/, 

	TMMFMessageDestination* /*aSinkHandle*/)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::MfaocComplete++");

    DEBUG_PRINTF3("CVideoPlayerUtility::CBody::MfaocComplete - aError %d, aControllerUid 0x%X", aError, aControllerUid.iUid);

	iCallbackOpenReceived = ETrue;

	// save the error in iOpenError -

	// unless HandleEvent(KMMFEventCategoryVideoOpenComplete) 

	// has reported an error already

	if (iOpenError == KErrNone)

		iOpenError = aError;

	if (iOpenError == KErrNone)

		{

#ifdef SYMBIAN_BUILD_GCE

		// Check if the graphics surfaces is supported

		TInt err = CheckSurfaceSupported();

		DEBUG_PRINTF4("CVideoPlayerUtility::CBody::MfaocComplete - Checked surfaces supported - Err %d, Surfaces supported %d, Using VPU2 %d", err, iGraphicsSurfaceSupported, iUsingVPU2);

		if (!iGraphicsSurfaceSupported)

			{

			if (err != KErrNone && iUsingVPU2)

				{

				// Set KErrNotSupported if the controller doesn't support graphics surface and 

				// the open source is using CVideoPlayerUtility2

				iOpenError = err;

				}

			else

				{

				SetAndUpdateWindow();

				}

			}

#else

		SetAndUpdateWindow();

#endif // SYMBIAN_BUILD_GCE	

		// now that the controller is open

		if (iOpenError == KErrNone)

			{

			iControllerOpen = ETrue;

			iControllerUid = aControllerUid;

#ifdef SYMBIAN_BUILD_GCE		

			// We are using a controller that supports graphics surfaces but are not in surface mode.  

			// Call AddDisplay so we can render to surfaces using the CVideoUtility API.

			if (iGraphicsSurfaceSupported && !iUsingVPU2)

				{

				if (iDirectScreenAccess)

					{

		 			iDirectScreenAccess->Cancel();

					}

		        // When using surfaces for CVPU we use DoAddDisplayWindowL() which requires clip rectangle and video extent

		        // as arguments. Video extent is not supported by CVPU so aWindowRect is used instead. This function

		        // assumes these args are relative to the window. However they are relative to the display and must be

		        // converted.

		        TRect windowRectRelativeToWindow;

		        TRect clipRectRelativeToWindow;     

		        ConvertFromRelativeToDisplayToRelativeToWindow(*iWindow, iWindowRect, iClipRect, windowRectRelativeToWindow, clipRectRelativeToWindow);

				TRAP(iOpenError, DoAddDisplayWindowL(*iWs, iDisplayId, *iWindow, clipRectRelativeToWindow, windowRectRelativeToWindow, NULL));				

				}

#endif		

			}

		// If an error occurred in any of the above, try for next controller if present

		// in the selection list.

		else

			{

			if(iFindAndOpenController->ControllerIndex() < (iFindAndOpenController->ControllerCount())-1)

				{

				aError = iOpenError;

				if (iAsyncCallback)

					{

					iAsyncCallback->Cancel();

					}

				if (iControllerEventMonitor)

					{

					iControllerEventMonitor->Cancel();

					}

				iOpenError = KErrNone;

				return;

				}

			Close();

			}

		}

	if(iOpenError != KErrNone && !iControllerOpen)

		{

		if (iFindAndOpenController)	

			{

			//if try next controller was called when specific controller uid was 

			//given, skip the searching and report error.

			if(!iFindAndOpenController->StopTryLoadController()) 

				{

				if( !(aError == KErrNoMemory || aError == KErrCancel ) ) 

					{

					if(iFindAndOpenController->ControllerIndex() < (iFindAndOpenController->ControllerCount())-1)

						{

						aError = iOpenError;   // Actually tries to load controller

						iOpenError = KErrNone;

						return;

						}

					}

				}

			}

		}

	// if we've already received the open complete event

	// call the client now (otherwise wait for it)

	if (iEventOpenReceived || iOpenError != KErrNone)

		{

		// stop a subsequent HandleEvent(KMMFEventCategoryVideoOpenComplete) 

		// from issuing another callback to client

		iCallbackOpenReceived = EFalse;

		iAsyncCallback->Signal(iOpenError, CMMFVideoPlayerCallback::EOpenCompleteEvent);

		}

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::MfaocComplete--");

	}

void CVideoPlayerUtility::CBody::OpenFileL(const TDesC& aFileName, TUid aControllerUid)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenFileL (filename)++");

	TMMFileSource filesource(aFileName, KDefaultContentObject, EPlay);

	OpenFileL(filesource, aControllerUid);

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenFileL (filename)--");

	}

void CVideoPlayerUtility::CBody::OpenFileL(const RFile& aFile, TUid aControllerUid)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenFileL (filehandle)++");

	RFile& file = const_cast<RFile&>(aFile);

	TMMFileHandleSource filehandlesource(file, KDefaultContentObject, EPlay);

	OpenFileL(filehandlesource, aControllerUid);

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenFileL (filehandle)--");

	}

void CVideoPlayerUtility::CBody::OpenFileL(const TMMSource& aSource, TUid aControllerUid)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenFileL (source)++");

    DEBUG_PRINTF2("CVideoPlayerUtility::CBody::OpenFileL - aControllerUid 0x%X", aControllerUid.iUid);

	// Make sure we are closed

	Reset();

	iFindAndOpenController->ConfigureSourceSink(

		aSource,

		CMMFFindAndOpenController::TSourceSink(KUidMmfAudioOutput));

#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

	iFindAndOpenController->SetInitScreenNumber(iScreenNumber, &iVideoSetInitScreenCustomCommands);

#endif

	if (aControllerUid != KNullUid) 

		{

		iFindAndOpenController->OpenByControllerUid(aControllerUid);

		}

	else

		{

		iFindAndOpenController->OpenByFileSource(aSource);

		}

	DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenFileL (source)--");

	}

//

// This method launches and initializes plugin controller based on the stream 

// source header passed in the descriptor buffer.

//

void CVideoPlayerUtility::CBody::OpenDesL(const TDesC8& aDescriptor, TUid aControllerUid)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenDesL++");

	// Make sure we are closed

	Reset();

	iFindAndOpenController->ConfigureSourceSink(

		CMMFFindAndOpenController::TSourceSink(KUidMmfDescriptorSource, CMMFFindAndOpenController::GetConfigDescriptor(aDescriptor)), 

		CMMFFindAndOpenController::TSourceSink(KUidMmfAudioOutput, KNullDesC8));

#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

	iFindAndOpenController->SetInitScreenNumber(iScreenNumber, &iVideoSetInitScreenCustomCommands);

#endif

	if (aControllerUid!=KNullUid)

		{

		iFindAndOpenController->OpenByControllerUid(aControllerUid);

		}

	else

		{

		iFindAndOpenController->OpenByDescriptor(aDescriptor);

		}

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenDesL--");

	}

void CVideoPlayerUtility::CBody::OpenUrlL(const TDesC& aUrl, TInt aIapId, const TDesC8& aMimeType, TUid aControllerUid)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenUrlL++");

	// Make sure we are closed

	Reset();

	CBufFlat* urlCfgBuffer = NULL;

    CMMFFindAndOpenController::GetConfigUrlL(urlCfgBuffer, aUrl, aIapId);

	iFindAndOpenController->ConfigureSourceSink(

		CMMFFindAndOpenController::TSourceSink(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)), 

		CMMFFindAndOpenController::TSourceSink(KUidMmfAudioOutput, KNullDesC8));

#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

	iFindAndOpenController->SetInitScreenNumber(iScreenNumber, &iVideoSetInitScreenCustomCommands);

#endif

	if (aControllerUid!=KNullUid)

		{

		iFindAndOpenController->OpenByControllerUid(aControllerUid);

		}

	else

		iFindAndOpenController->OpenByUrl(aUrl, aIapId, aMimeType);

	delete urlCfgBuffer;

	DEBUG_PRINTF("CVideoPlayerUtility::CBody::OpenUrlL--");

	}

void CVideoPlayerUtility::CBody::Play()

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::Play++");

	TInt err = iController.Prime();

	if (err == KErrNone)

		err = iController.Play();

	if (err != KErrNone)

	    {

	    iAsyncCallback->Signal(err,CMMFVideoPlayerCallback::EPlayCompleteEvent);

	    DEBUG_PRINTF2("CVideoPlayerUtility::CBody::Play (exit 1)-- - Err %d", err);

	    return;

	    }

	iState = EPlaying;

	//If Audio Resource Notification request is pending - attempt now

	if(iArnEventHolder != KNullUid)

		{

		err = iNotificationRegistrationCommands.RegisterAsClient(iArnEventHolder, iNotificationDataHolder);

		iArnEventHolder = KNullUid;

		iNotificationDataHolder = KNullDesC8;

		if(err != KErrNone)

			{

			iAsyncCallback->Signal(err, CMMFVideoPlayerCallback::EPlayCompleteEvent);

			}

		}

    DEBUG_PRINTF2("CVideoPlayerUtility::CBody::Play-- - Err %d", err);

	}

void CVideoPlayerUtility::CBody::Play(const TTimeIntervalMicroSeconds& aStartTime, const TTimeIntervalMicroSeconds& aEndTime)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::Play++");

    DEBUG_PRINTF3("CVideoPlayerUtility::CBody::Play - aStartTime %ld, aEndTime %ld", aStartTime.Int64(), aEndTime.Int64());

	TInt err = iController.Prime();

	if (err == KErrNone)

	err = iVideoPlayControllerCustomCommands.Play(aStartTime, aEndTime);

	if (err != KErrNone)

	    {

	    iAsyncCallback->Signal(err, CMMFVideoPlayerCallback::EPlayCompleteEvent);

		DEBUG_PRINTF2("CVideoPlayerUtility::CBody::Play (exit1)-- - Err %d", err);

	    return;

	    }

	iState = EPlaying;

	//If Audio Resource Notification request is pending - attempt now

	if(iArnEventHolder != KNullUid)

		{

		err = iNotificationRegistrationCommands.RegisterAsClient(iArnEventHolder, iNotificationDataHolder);			

		iArnEventHolder = KNullUid;

		iNotificationDataHolder = KNullDesC8;

		if(err != KErrNone)

			{

			iAsyncCallback->Signal(err, CMMFVideoPlayerCallback::EPlayCompleteEvent);

			}

		}

    DEBUG_PRINTF2("CVideoPlayerUtility::CBody::Play-- - Err %d", err);

	}

TInt CVideoPlayerUtility::CBody::Stop()

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::Stop++");

	TInt err = iController.Stop();

	iState = EStopped;

    DEBUG_PRINTF2("CVideoPlayerUtility::CBody::Stop-- - Err %d", err);

	return err;

	}

void CVideoPlayerUtility::CBody::PauseL()

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::PauseL++");

	User::LeaveIfError(iController.Pause());

	iState = EPaused;

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::PauseL--");

	}

void CVideoPlayerUtility::CBody::SetVolumeL(TInt aVolume)

	{

	User::LeaveIfError(iAudioPlayDeviceCustomCommands.SetVolume(aVolume));

	}

void CVideoPlayerUtility::CBody::PrepareDSAL(RWsSession& aWs, CWsScreenDevice& aScreenDevice, RWindowBase& aWindow)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::PrepareDSAL++");

	CDirectScreenAccess* old = iDirectScreenAccess;

	iDirectScreenAccess = CDirectScreenAccess::NewL(aWs,aScreenDevice,aWindow,*this);

	delete old;

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::PrepareDSAL - Starting");

	iDirectScreenAccess->StartL();

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::PrepareDSAL--");

	}

void CVideoPlayerUtility::CBody::SetDisplayWindowL(RWsSession& aWs, CWsScreenDevice& aScreenDevice,

							RWindowBase& aWindow, const TRect& aWindowRect,

							const TRect& aClipRect)

	{	

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetDisplayWindowL++");

    DEBUG_PRINTF4("CVideoPlayerUtility::CBody::SetDisplayWindowL - aScreenDevice num %d, width %d, height %d", aScreenDevice.GetScreenNumber(), aScreenDevice.SizeInPixels().iWidth, aScreenDevice.SizeInPixels().iHeight);

    DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SetDisplayWindowL - aWindow WsHandle 0x%X", aWindow.WsHandle());

    DEBUG_PRINTF5("CVideoPlayerUtility::CBody::SetDisplayWindowL - aWindow abs pos %d,%d - width %d, height %d", aWindow.AbsPosition().iX, aWindow.AbsPosition().iY, aWindow.Size().iWidth, aWindow.Size().iHeight);

    DEBUG_PRINTF5("CVideoPlayerUtility::CBody::SetDisplayWindowL - aWindowRect %d,%d - %d,%d", aWindowRect.iTl.iX, aWindowRect.iTl.iY, aWindowRect.iBr.iX, aWindowRect.iBr.iY);

    DEBUG_PRINTF5("CVideoPlayerUtility::CBody::SetDisplayWindowL - aClipRect %d,%d - %d,%d", aClipRect.iTl.iX, aClipRect.iTl.iY, aClipRect.iBr.iX, aClipRect.iBr.iY);

    iWindowRect = aWindowRect;

	iClipRect = aClipRect;

#ifdef SYMBIAN_BUILD_GCE

	// If called from CVideoPlayerUtility2, fail with KErrNotSupport. Otherwise, if the controller supports 

	// the graphics surfaces, it will render to graphics surfaces. If the controller doesn't support 

	// the graphics surfaces, it will use direct screen access.

	if (iUsingVPU2)

		{

		User::Leave(KErrNotSupported);

		}

	// If the controller does not support GCE or the source has not been opened, start new DSA.

	if (!iGraphicsSurfaceSupported)

		{

		PrepareDSAL(aWs, aScreenDevice, aWindow);

		}

	if (!iGraphicsSurfaceSupported && iControllerOpen)

		{

		// Set display window and update region, if controller is open

		User::LeaveIfError(iVideoPlayControllerCustomCommands.SetDisplayWindow(iWindowRect,iClipRect));

		User::LeaveIfError(iVideoPlayControllerCustomCommands.UpdateDisplayRegion(*iDirectScreenAccess->DrawingRegion()));

		}

	if (iGraphicsSurfaceSupported && iControllerOpen)

		{

		// When the controller supports graphics surfaces, need to stop direct screen access.

 		if (iDirectScreenAccess)

 			{

 			iDirectScreenAccess->Cancel();

  			AbortNow(RDirectScreenAccess::ETerminateCancel);

 			}

		// When using surfaces for CVPU we use DoAddDisplayWindowL() which requires clip rectangle and video extent

		// as arguments. Video extent is not supported by CVPU so aWindowRect is used instead. This function

		// assumes these args are relative to the window. However they are relative to the display and must be

		// converted.

		TRect windowRectRelativeToWindow;

		TRect clipRectRelativeToWindow;		

		ConvertFromRelativeToDisplayToRelativeToWindow(aWindow, aWindowRect, aClipRect, windowRectRelativeToWindow, clipRectRelativeToWindow);

		// check if display for window already exists and if so do an update else create a new display

		TRAPD(err, CMediaClientVideoDisplayBody::FindDisplayWithWindowL(iActiveDisplays, aWindow));

		if (err == KErrNone)

		    {

		    DoUpdateDisplayWindowL(aWs, aWindow, clipRectRelativeToWindow, windowRectRelativeToWindow, NULL);

		    }

		else

		    {

		    DoAddDisplayWindowL(aWs, aScreenDevice.GetScreenNumber(), aWindow, clipRectRelativeToWindow, windowRectRelativeToWindow, NULL);

		    }

		}

#else

	PrepareDSAL(aWs, aScreenDevice, aWindow);

	if (iControllerOpen)

		{

		// Set display window and update region, if controller is open

		User::LeaveIfError(iVideoPlayControllerCustomCommands.SetDisplayWindow(iWindowRect,iClipRect));

		User::LeaveIfError(iVideoPlayControllerCustomCommands.UpdateDisplayRegion(*iDirectScreenAccess->DrawingRegion()));

		if(iDirectScreenAccessAbort)

			{

			User::LeaveIfError(iVideoPlayControllerCustomCommands.DirectScreenAccessEvent(EResumeDSA));

			iDirectScreenAccessAbort = EFalse;

			}

		}

#endif

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetDisplayWindowL--");

	}

TReal32 CVideoPlayerUtility::CBody::VideoFrameRateL() const

	{

	TReal32 framerate = 0;

	User::LeaveIfError(iVideoControllerCustomCommands.GetFrameRate(framerate));

	return framerate;

	}

void CVideoPlayerUtility::CBody::VideoFrameSizeL(TSize& aSize) const

	{

	User::LeaveIfError(iVideoControllerCustomCommands.GetVideoFrameSize(aSize));

	}

TInt CVideoPlayerUtility::CBody::Volume() const

	{

	TInt vol = 0;

	iAudioPlayDeviceCustomCommands.GetVolume(vol);

	return vol;

	}

void CVideoPlayerUtility::CBody::SetBalanceL(TInt aBalance)

	{

	User::LeaveIfError(iAudioPlayDeviceCustomCommands.SetBalance(aBalance));

	}

TInt CVideoPlayerUtility::CBody::Balance() const

	{

	TInt bal = 0;

	iAudioPlayDeviceCustomCommands.GetBalance(bal);

	return bal;

	}

void CVideoPlayerUtility::CBody::SetRotationL(TVideoRotation aRotation)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetRotationL++");

    DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SetRotationL - aRotation %d", aRotation);

#ifdef SYMBIAN_BUILD_GCE

	if (!iGraphicsSurfaceSupported)

		{

		User::LeaveIfError(iVideoPlayControllerCustomCommands.SetRotation(aRotation));

		}

	else

		{

		// Rotation setting is not sent to controller when graphics surfaces are used.

		// If the surface has been created, perform rotation with the help of graphics surfaces;

		// otherwise, just store the rotation info.

		TInt count = iActiveDisplays.Count();

		for (TInt i = 0; i < count; ++i)

			{

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

			CMediaClientVideoDisplayBody* display = iActiveDisplays[i];

			RArray<CMediaClientVideoDisplayBody::TWindowData>& windows = display->Windows();

			TInt windowcount = windows.Count();	

			for (TInt i = 0; i < windowcount; ++i)

				{

				CMediaClientVideoDisplayBody::TWindowData& window = windows[i];		

				if (window.iRotation != aRotation)

					{

					// update config only if setting has actually changed

					display->SetRotationL(*window.iWindow, aRotation, iCropRegion);

					if (iSubtitleUtility)

						{

						TMMFSubtitleWindowConfig config;

						GetSubtitleConfigFromWindowData(window, config);

						iSubtitleUtility->UpdateSubtitleConfig(config);

						}

					}

				}

#else

			iActiveDisplays[i]->SetRotationL(aRotation, iCropRegion);

#endif//SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

			}

		iGlobalRotation = aRotation;

		}

#else 

	User::LeaveIfError(iVideoPlayControllerCustomCommands.SetRotation(aRotation));

#endif // SYMBIAN_BUILD_GCE

	DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetRotationL--");

	}

TVideoRotation CVideoPlayerUtility::CBody::RotationL() const

	{

	TVideoRotation rot = EVideoRotationNone;

#ifdef SYMBIAN_BUILD_GCE

	if (!iGraphicsSurfaceSupported)

		{		

		User::LeaveIfError(iVideoPlayControllerCustomCommands.GetRotation(rot));		

		}

	else 

		{

		// Rotation setting is not retrieved from controller when graphics surfaces are used.

		rot = iGlobalRotation;

		}

#else

	User::LeaveIfError(iVideoPlayControllerCustomCommands.GetRotation(rot));

#endif // SYMBIAN_BUILD_GCE

	return rot;

	}

void CVideoPlayerUtility::CBody::SetScaleFactorL(TReal32 aWidthPercentage, TReal32 aHeightPercentage, TBool aAntiAliasFiltering)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetScaleFactorL");

    DEBUG_PRINTF4("CVideoPlayerUtility::CBody::SetScaleFactorL - aWidthPercentage %f, aHeightPercentage %f, aAntiAliasFiltering %d", aWidthPercentage, aHeightPercentage, aAntiAliasFiltering);

#ifdef SYMBIAN_BUILD_GCE

	if (!iGraphicsSurfaceSupported)

		{

		User::LeaveIfError(iVideoPlayControllerCustomCommands.SetScaleFactor(aWidthPercentage, aHeightPercentage, aAntiAliasFiltering));

		}

	else

		{

		// Scale factor  setting is not sent to controller when graphics surfaces are used.

		// If the surface has been created, perform scale factor with the help of graphics surfaces.

		iAntiAliasFiltering = aAntiAliasFiltering;

		iGlobalScaleWidth = aWidthPercentage;

		iGlobalScaleHeight = aHeightPercentage;

		iGlobalAutoScaleType = EAutoScaleNone;

		TInt count = iActiveDisplays.Count();

		for (TInt i = 0; i < count; ++i)

			{

			iActiveDisplays[i]->SetScaleFactorL(aWidthPercentage, aHeightPercentage, iCropRegion);

			}

		}

#else

	User::LeaveIfError(iVideoPlayControllerCustomCommands.SetScaleFactor(aWidthPercentage, aHeightPercentage, aAntiAliasFiltering));

#endif	// SYMBIAN_BUILD_GCE

	DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetScaleFactorL--");

	}

void CVideoPlayerUtility::CBody::GetScaleFactorL(TReal32& aWidthPercentage, TReal32& aHeightPercentage, TBool& aAntiAliasFiltering) const

	{

#ifdef SYMBIAN_BUILD_GCE

	if (!iGraphicsSurfaceSupported)

		{

		User::LeaveIfError(iVideoPlayControllerCustomCommands.GetScaleFactor(aWidthPercentage, aHeightPercentage, aAntiAliasFiltering));

		}

	else

		{

		// Scale factor setting is not retrieved from controller when graphics surfaces are used.

		aWidthPercentage = iGlobalScaleWidth;

		aHeightPercentage = iGlobalScaleHeight;	

		aAntiAliasFiltering = iAntiAliasFiltering;

		}

#else

	User::LeaveIfError(iVideoPlayControllerCustomCommands.GetScaleFactor(aWidthPercentage, aHeightPercentage, aAntiAliasFiltering));	

#endif // SYMBIAN_BUILD_GCE

	}

void CVideoPlayerUtility::CBody::SetCropRegionL(const TRect& aCropRegion)

	{

#ifdef SYMBIAN_BUILD_GCE

	if (!iGraphicsSurfaceSupported)

		{

		User::LeaveIfError(iVideoPlayControllerCustomCommands.SetCropRegion(aCropRegion));

		}

	else

		{

		// Crop region setting is not sent to controller when graphics surfaces are used.

		// If the surface has been created, perform crop region with the help of graphics surfaces;

		// otherwise, just store the crop region info.

		if (aCropRegion != iCropRegion)

			{

			iCropRegion = aCropRegion;

			User::LeaveIfError(SetAllBackgroundSurfaces());

			}

		}

#else

	User::LeaveIfError(iVideoPlayControllerCustomCommands.SetCropRegion(aCropRegion));

#endif // SYMBIAN_BUILD_GCE

	}

void CVideoPlayerUtility::CBody::GetCropRegionL(TRect& aCropRegion) const

	{

#ifdef SYMBIAN_BUILD_GCE

	if (!iGraphicsSurfaceSupported )

		{

		User::LeaveIfError(iVideoPlayControllerCustomCommands.GetCropRegion(aCropRegion));

		}

	else

		{

		// Crop rectangle setting is not retrieved from controller when graphics surfaces are used.

		aCropRegion = iCropRegion;

		}

#else

	User::LeaveIfError(iVideoPlayControllerCustomCommands.GetCropRegion(aCropRegion));

#endif // SYMBIAN_BUILD_GCE

	}

void CVideoPlayerUtility::CBody::Prepare()

	{

	TInt error = iVideoPlayControllerCustomCommands.Prepare();

	if (error)

		iObserver.MvpuoPrepareComplete(error);

	}

const TDesC8& CVideoPlayerUtility::CBody::VideoFormatMimeType() const

	{

	TPtr8 des = iMimeType->Des();

	TInt err = iVideoControllerCustomCommands.GetVideoMimeType(des);

	if (!err)

		return *iMimeType;

	else

		return KNullDesC8;

	}

void CVideoPlayerUtility::CBody::RegisterForVideoLoadingNotification(MVideoLoadingObserver& aObserver)

	{

	iVideoLoadingObserver = &aObserver;

	}

TInt CVideoPlayerUtility::CBody::NumberOfMetaDataEntriesL() const

	{

	TInt num = 0;

	User::LeaveIfError(iController.GetNumberOfMetaDataEntries(num));

	return num;

	}

CMMFMetaDataEntry* CVideoPlayerUtility::CBody::MetaDataEntryL(TInt aMetaDataIndex) const

	{

	return iController.GetMetaDataEntryL(aMetaDataIndex);

	}

void CVideoPlayerUtility::CBody::SetPriorityL(TInt aPriority, TInt aPref)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetPriorityL++");

    DEBUG_PRINTF3("CVideoPlayerUtility::CBody::SetPriorityL - aPriority %d, aPref %d", aPriority, aPref);

    iPrioritySettings.iPref = aPref;

	iPrioritySettings.iPriority = aPriority;

	TInt err = iController.SetPrioritySettings(iPrioritySettings);

	if ((err == KErrNone) || (err == KErrNotReady))

		{

		iFindAndOpenController->Configure(KUidMediaTypeVideo, iPrioritySettings, CMMFPluginSelectionParameters::EAllowOtherMediaIds);

		}

	else

		{

		User::Leave(err);

		}

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetPriorityL--");

	}

void CVideoPlayerUtility::CBody::PriorityL(TInt & aPriority, TMdaPriorityPreference &aPref) const 

	{

	aPriority = iPrioritySettings.iPriority;

	aPref = TMdaPriorityPreference(iPrioritySettings.iPref);

	}

void CVideoPlayerUtility::CBody::SetPositionL(const TTimeIntervalMicroSeconds& aPosition)

	{

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetPositionL++");

    DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SetPositionL - aPosition %ld", aPosition.Int64());

	User::LeaveIfError(iController.SetPosition(aPosition));

    DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetPositionL--");

	}

TTimeIntervalMicroSeconds CVideoPlayerUtility::CBody::DurationL() const

	{

	TTimeIntervalMicroSeconds duration;

	User::LeaveIfError(iController.GetDuration(duration));

	return duration;

	}

TTimeIntervalMicroSeconds CVideoPlayerUtility::CBody::PositionL() const

	{

	TTimeIntervalMicroSeconds position;

	User::LeaveIfError(iController.GetPosition(position));

	return position;

	}

TInt CVideoPlayerUtility::CBody::MaxVolume() const

	{

	TInt maxVol = 0;

	iAudioPlayDeviceCustomCommands.GetMaxVolume(maxVol);

	return maxVol;

	}

void CVideoPlayerUtility::CBody::GetFrameL(TDisplayMode aDisplayMode, TBool aUseIntentAPI, TIntent aIntent)