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