FCL/sf/os/mm: comparison mmlibs/mmfw/src/Client/Video/mmfclientvideoplayerbody.cpp

equal deleted inserted replaced

-:40261b775718
+:efebd1779a59
-// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+// 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".
 #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
 															 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 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)
 	iController.Close();
 	iControllerUid = KNullUid;
 	iControllerOpen = EFalse;
 	iDirectScreenAccessAbort = EFalse;
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::Close--");
 	}
 CVideoPlayerUtility::CBody::CBody(CVideoPlayerUtility* aParent,
 								  MVideoPlayerUtilityObserver& aObserver,
 								  TInt aScreenNumber,
 	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
 	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);
 	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)
 		{
 #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)
 				{
 		// 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,
 		}
 	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)),
 		}
 	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);
 		}
 	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)
 		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)
 		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)
 	{
-	iWindowRect = aWindowRect;
+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
 			User::LeaveIfError(iVideoPlayControllerCustomCommands.DirectScreenAccessEvent(EResumeDSA));
 			iDirectScreenAccessAbort = EFalse;
 			}
 		}
 #endif
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetDisplayWindowL--");
 	}
 TReal32 CVideoPlayerUtility::CBody::VideoFrameRateL() const
 	{
 	TReal32 framerate = 0;
 	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
 	User::LeaveIfError(iVideoPlayControllerCustomCommands.SetRotation(aRotation));
 #endif // SYMBIAN_BUILD_GCE
+	DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetRotationL--");
 	}
 TVideoRotation CVideoPlayerUtility::CBody::RotationL() const
 	{
 	TVideoRotation rot = EVideoRotationNone;
 	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
 	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
 	return iController.GetMetaDataEntryL(aMetaDataIndex);
 	}
 void CVideoPlayerUtility::CBody::SetPriorityL(TInt aPriority, TInt aPref)
 	{
-	iPrioritySettings.iPref = 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))
 		{
 		}
 	else
 		{
 		User::Leave(err);
 		}
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetPriorityL--");
 	}
 void CVideoPlayerUtility::CBody::PriorityL(TInt & aPriority, TMdaPriorityPreference &aPref) const
 	{
 	aPriority = iPrioritySettings.iPriority;
 	}
 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
 	{
 	}
 void CVideoPlayerUtility::CBody::HandleEvent(const TMMFEvent& aEvent)
 	{
-	if (aEvent.iEventType == KMMFEventCategoryVideoOpenComplete)
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::HandleEvent++");
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::HandleEvent - Event type 0x%X", aEvent.iEventType);
+if (aEvent.iEventType == KMMFEventCategoryVideoOpenComplete)
 		{
 		// if we haven't had a MfaocComplete() callback yet,
 		// we need to delay the call back to the client
 		// because the source/sink will not have been opened yet.
 		iEventOpenReceived = ETrue;
 		}
 #endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT
 	else
 		// Pass on all unrecognised events to the client
 		iObserver.MvpuoEvent(aEvent);
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::HandleEvent--");
 	}
 #ifdef SYMBIAN_BUILD_GCE
 TInt CVideoPlayerUtility::CBody::SurfaceCreated()
 	{
-	TInt count = iActiveDisplays.Count();
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SurfaceCreated++");
+TInt count = iActiveDisplays.Count();
 	TBool replaceSurface = !(iSurfaceId.IsNull());
 	TSurfaceId oldSurfaceId(iSurfaceId);
 	// first remove surface if one already in use
 	if(replaceSurface)
 if (error2 != KErrNone)
 {
 error = error2;
 }
 }
-return error;
+	DEBUG_PRINTF("CVideoPlayerUtility::CBody::SurfaceCreated--");
+	return error;
 	}
 TInt CVideoPlayerUtility::CBody::SurfaceParametersChanged()
 	{
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SurfaceParametersChanged++");
 	if (iSurfaceId.IsNull())
 		{
 		return KErrNotSupported;
 		}
 		if ((error2 != KErrNone) && (error == KErrNone))
 			{
 			error = error2;
 			}
 		}
-	return error;
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SurfaceParametersChanged-- - Error %d", error);
+return error;
 	}
 TInt CVideoPlayerUtility::CBody::SetAllBackgroundSurfaces()
 	{
 	TInt count = iActiveDisplays.Count();
 	return err;
 	}
 TInt CVideoPlayerUtility::CBody::RemoveSurface(TBool aControllerEvent)
 	{
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::RemoveSurface++");
 	if (iSurfaceId.IsNull())
 		{
 		return KErrNotFound;
 		}
 	TInt error = iVideoPlaySurfaceSupportCustomCommands.SurfaceRemoved(iSurfaceId);
 	iSurfaceId = TSurfaceId::CreateNullId();
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::RemoveSurface-- - Error %d", error);
 	return error;
 	}
 #endif // SYMBIAN_BUILD_GCE
 void CVideoPlayerUtility::CBody::AddDisplayWindowL(RWsSession& aWs, CWsScreenDevice& aScreenDevice,
 							RWindow& aWindow, const TRect& aVideoExtent,
 							const TRect& aWindowClipRect)
 	{
-	// set window and get display ID for the window
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::AddDisplayWindowL++");
+DEBUG_PRINTF4("CVideoPlayerUtility::CBody::AddDisplayWindowL - aScreenDevice num %d, width %d, height %d", aScreenDevice.GetScreenNumber(), aScreenDevice.SizeInPixels().iWidth, aScreenDevice.SizeInPixels().iHeight);
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::AddDisplayWindowL - aWindow WsHandle 0x%X", aWindow.WsHandle());
+DEBUG_PRINTF5("CVideoPlayerUtility::CBody::AddDisplayWindowL - 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::AddDisplayWindowL - aVideoExtent %d,%d - %d,%d", aVideoExtent.iTl.iX, aVideoExtent.iTl.iY, aVideoExtent.iBr.iX, aVideoExtent.iBr.iY);
+DEBUG_PRINTF5("CVideoPlayerUtility::CBody::AddDisplayWindowL - aWindowClipRect %d,%d - %d,%d", aWindowClipRect.iTl.iX, aWindowClipRect.iTl.iY, aWindowClipRect.iBr.iX, aWindowClipRect.iBr.iY);
+// set window and get display ID for the window
 	TRect windowRect = TRect(aWindow.Size());
 	// Check the rectangle is contained completely within the window
 	if (!RectContains(windowRect, aWindowClipRect))
 		{
 		//       behaviour in this case
 		User::Leave(KErrArgument);
 		}
 	DoAddDisplayWindowL(aWs, aScreenDevice.GetScreenNumber(), aWindow, aWindowClipRect, aVideoExtent, &aWindow);
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::AddDisplayWindowL--");
 	}
 void CVideoPlayerUtility::CBody::AddDisplayWindowL(RWsSession& aWs, CWsScreenDevice& aScreenDevice, RWindow& aWindow)
 	{
-	DoAddDisplayWindowL(aWs, aScreenDevice.GetScreenNumber(), aWindow, TRect(aWindow.Size()), TRect(aWindow.Size()), &aWindow);
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::AddDisplayWindowL++");
+DEBUG_PRINTF4("CVideoPlayerUtility::CBody::AddDisplayWindowL - aScreenDevice num %d, width %d, height %d", aScreenDevice.GetScreenNumber(), aScreenDevice.SizeInPixels().iWidth, aScreenDevice.SizeInPixels().iHeight);
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::AddDisplayWindowL - aWindow WsHandle 0x%X", aWindow.WsHandle());
+DEBUG_PRINTF5("CVideoPlayerUtility::CBody::AddDisplayWindowL - aWindow abs pos %d,%d - width %d, height %d", aWindow.AbsPosition().iX, aWindow.AbsPosition().iY, aWindow.Size().iWidth, aWindow.Size().iHeight);
+DoAddDisplayWindowL(aWs, aScreenDevice.GetScreenNumber(), aWindow, TRect(aWindow.Size()), TRect(aWindow.Size()), &aWindow);
+	DEBUG_PRINTF("CVideoPlayerUtility::CBody::AddDisplayWindowL--");
 	}
 void CVideoPlayerUtility::CBody::DoAddDisplayWindowL(RWsSession& aWs, TInt aDisplayId, RWindowBase& aWindow,
 								const TRect& aClipRect, const TRect& aVideoExtent, RWindow* aWindow2)
 	{
 	if (pos == KErrNotFound)
 		{
 		if(iSurfaceId.IsNull())
 			{
-			display = CMediaClientVideoDisplayBody::NewL(aDisplayId);
+			display = CMediaClientVideoDisplayBody::NewL(aDisplayId, ETrue);
 			}
 		else
 			{
-			display = CMediaClientVideoDisplayBody::NewL(aDisplayId, iSurfaceId, iSurfaceCropRect, iAspectRatio);
+			display = CMediaClientVideoDisplayBody::NewL(aDisplayId, iSurfaceId, iSurfaceCropRect, iAspectRatio, ETrue);
 			}
 		CleanupStack::PushL(display);
 		iActiveDisplays.InsertInOrderL(display, CMediaClientVideoDisplayBody::Compare);
 		CleanupStack::Pop(display);
 		}
 #endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT
 	}
 void CVideoPlayerUtility::CBody::RemoveDisplayWindow(RWindowBase& aWindow)
 	{
-	CMediaClientVideoDisplayBody* display = NULL;
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::RemoveDisplayWindow++");
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::RemoveDisplayWindow - aWindow WsHandle 0x%X", aWindow.WsHandle());
+CMediaClientVideoDisplayBody* display = NULL;
 	TRAPD(err, display = CMediaClientVideoDisplayBody::FindDisplayWithWindowL(iActiveDisplays, aWindow));
 	if (err == KErrNone)
 		{
 		display->RemoveDisplayWindow(aWindow);
 			// subtitles are enabled, so remove window config, ignore error
 			iSubtitleUtility->RemoveSubtitleConfig(aWindow.WsHandle());
 			}
 #endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT
 		}
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::RemoveDisplayWindow--");
 	}
 void CVideoPlayerUtility::CBody::AddDisplayL(TInt aDisplay, MMMFSurfaceEventHandler& aEventHandler)
 	{
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::AddDisplayL");
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::AddDisplayL - aDisplay %d", aDisplay);
 	if (!iControllerOpen)
 		{
 		User::Leave(KErrNotReady);
 		}
 	if (err == KErrNotFound)
 		{
 		CMediaClientVideoDisplayBody* display;
 		if(iSurfaceId.IsNull())
 			{
-			display = CMediaClientVideoDisplayBody::NewL(aDisplay);
+			display = CMediaClientVideoDisplayBody::NewL(aDisplay, ETrue);
 			}
 		else
 			{
-			display = CMediaClientVideoDisplayBody::NewL(aDisplay, iSurfaceId, iSurfaceCropRect, iAspectRatio);
+			display = CMediaClientVideoDisplayBody::NewL(aDisplay, iSurfaceId, iSurfaceCropRect, iAspectRatio, ETrue);
 			}
 		CleanupStack::PushL(display);
 		iActiveDisplays.InsertInOrderL(display, CMediaClientVideoDisplayBody::Compare);
 		CleanupStack::Pop(display);
 		display->AddDisplayL(aEventHandler);
 	else
 		{
 		User::LeaveIfError(err);
 		iActiveDisplays[err]->AddDisplayL(aEventHandler);
 		}
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::AddDisplayL--");
 	}
 void CVideoPlayerUtility::CBody::RemoveDisplay(TInt aDisplay)
 	{
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::RemoveDisplay++");
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::RemoveDisplay - aDisplay %d", aDisplay);
 	TInt pos = iActiveDisplays.FindInOrder(aDisplay, CMediaClientVideoDisplayBody::CompareByDisplay);
 	if (pos >= KErrNone)
 		{
 		CMediaClientVideoDisplayBody* disp = iActiveDisplays[pos];
 			{
 			iActiveDisplays.Remove(pos);
 			delete disp;
 			}
 		}
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::RemoveDisplay--");
 	}
 void CVideoPlayerUtility::CBody::ConvertFromRelativeToDisplayToRelativeToWindow(
 const RWindowBase& aWindow,
 const TRect& aFromWindowRect,
 const TRect& aFromClipRect,
 TRect& aToWindowRect,
 TRect& aToClipRect)
 {
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::ConvertFromRelativeToDisplayToRelativeToWindow++");
 TPoint windowOrigin = aWindow.AbsPosition();
 // window rect
 aToWindowRect.iTl.iX = aFromWindowRect.iTl.iX - windowOrigin.iX;
 aToWindowRect.iTl.iY = aFromWindowRect.iTl.iY - windowOrigin.iY;
 // clip rect
 aToClipRect.iTl.iX = aFromClipRect.iTl.iX - windowOrigin.iX;
 aToClipRect.iTl.iY = aFromClipRect.iTl.iY - windowOrigin.iY;
 aToClipRect.iBr.iX = aFromClipRect.iBr.iX - windowOrigin.iX;
 aToClipRect.iBr.iY = aFromClipRect.iBr.iY - windowOrigin.iY;
+DEBUG_PRINTF5("CVideoPlayerUtility::CBody::ConvertFromRelativeToDisplayToRelativeToWindow - New Window rect %d,%d - %d,%d", aToWindowRect.iTl.iX, aToWindowRect.iTl.iY, aToWindowRect.iBr.iX, aToWindowRect.iBr.iY);
+DEBUG_PRINTF5("CVideoPlayerUtility::CBody::ConvertFromRelativeToDisplayToRelativeToWindow - New Clip rect %d,%d - %d,%d", aToClipRect.iTl.iX, aToClipRect.iTl.iY, aToClipRect.iBr.iX, aToClipRect.iBr.iY);
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::ConvertFromRelativeToDisplayToRelativeToWindow--");
 }
 void CVideoPlayerUtility::CBody::SetVideoExtentL(const RWindowBase& aWindow, const TRect& aVideoExtent)
 	{
-	// check opening the source is complete and the client has been recieved an MvpuoOpenComplete() callback
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetVideoExtentL++");
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SetVideoExtentL - aWindow WsHandle 0x%X", aWindow.WsHandle());
+DEBUG_PRINTF5("CVideoPlayerUtility::CBody::SetVideoExtentL - aVideoExtent %d,%d - %d,%d", aVideoExtent.iTl.iX, aVideoExtent.iTl.iY, aVideoExtent.iBr.iX, aVideoExtent.iBr.iY);
+// check opening the source is complete and the client has been recieved an MvpuoOpenComplete() callback
 	if (!iControllerOpen)
 		{
 		User::Leave(KErrNotReady);
 		}
 	CMediaClientVideoDisplayBody* display = CMediaClientVideoDisplayBody::FindDisplayWithWindowL(iActiveDisplays, aWindow);
 	display->SetVideoExtentL(aWindow, aVideoExtent, iCropRegion);
+	DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetVideoExtentL--");
 	}
 void CVideoPlayerUtility::CBody::SetWindowClipRectL(const RWindowBase& aWindow, const TRect& aWindowClipRect)
 	{
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetWindowClipRectL++");
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SetWindowClipRectL - aWindow WsHandle 0x%X", aWindow.WsHandle());
+DEBUG_PRINTF5("CVideoPlayerUtility::CBody::SetWindowClipRectL - aWindowClipRect %d,%d - %d,%d", aWindowClipRect.iTl.iX, aWindowClipRect.iTl.iY, aWindowClipRect.iBr.iX, aWindowClipRect.iBr.iY);
 // check opening the source is complete and the client has been recieved an MvpuoOpenComplete() callback
 	if (!iControllerOpen)
 		{
 		User::Leave(KErrNotReady);
 		}
 		UpdateSurfaceAndSubtitleConfigL(*display, currentWin, aWindowClipRect, currentWin.iRotation, iCropRegion);
 		}
 #else
 	display->SetWindowClipRectL(aWindow, aWindowClipRect, iCropRegion);
 #endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT
+	DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetWindowClipRectL--");
 	}
 // Check if the controller supports the graphics surface. Has to be called after resource opened.
 TInt CVideoPlayerUtility::CBody::CheckSurfaceSupported()
 	{
 	SetAutoScaleL(aWindow, aScaleType, EHorizontalAlignCenter, EVerticalAlignCenter);
 	}
 void CVideoPlayerUtility::CBody::SetAutoScaleL(const RWindowBase& aWindow, TAutoScaleType aScaleType, TInt aHorizPos, TInt aVertPos)
 	{
-	if (!iControllerOpen)
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetAutoScaleL++");
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SetAutoScaleL - aWindow WsHandle 0x%X", aWindow.WsHandle());
+DEBUG_PRINTF4("CVideoPlayerUtility::CBody::SetAutoScaleL - aScaleType %d, aHorizPos %d, aVertPos %d", aScaleType, aHorizPos, aVertPos);
+if (!iControllerOpen)
 		{
 		User::Leave(KErrNotReady);
 		}
 	CMediaClientVideoDisplayBody* display = CMediaClientVideoDisplayBody::FindDisplayWithWindowL(iActiveDisplays, aWindow);
 	display->SetAutoScaleL(aWindow, aScaleType, aHorizPos, aVertPos, iCropRegion);
+	DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetAutoScaleL--");
 	}
 void CVideoPlayerUtility::CBody::SetRotationL(const RWindowBase& aWindow, TVideoRotation aRotation)
 	{
-	if (!iControllerOpen)
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetRotationL++");
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SetRotationL - aWindow WsHandle 0x%X", aWindow.WsHandle());
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SetRotationL - aRotation %d", aRotation);
+if (!iControllerOpen)
 		{
 		User::Leave(KErrNotReady);
 		}
 	CMediaClientVideoDisplayBody* display = CMediaClientVideoDisplayBody::FindDisplayWithWindowL(iActiveDisplays, aWindow);
 		UpdateSurfaceAndSubtitleConfigL(*display, currentWin, currentWin.iClipRect, aRotation, iCropRegion);
 		}
 #else
 	display->SetRotationL(aWindow, aRotation, iCropRegion);
 #endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetRotationL--");
 	}
 TVideoRotation CVideoPlayerUtility::CBody::RotationL(const RWindowBase& aWindow) const
 	{
 	if (!iControllerOpen)
 	return display->RotationL(aWindow);
 	}
 void CVideoPlayerUtility::CBody::SetScaleFactorL(const RWindowBase& aWindow, TReal32 aWidthPercentage, TReal32 aHeightPercentage)
 	{
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetScaleFactorL++");
+DEBUG_PRINTF2("CVideoPlayerUtility::CBody::SetScaleFactorL - aWindow WsHandle 0x%X", aWindow.WsHandle());
+DEBUG_PRINTF3("CVideoPlayerUtility::CBody::SetScaleFactorL - aWidthPercentage %f, aHeightPercentage %f", aWidthPercentage, aHeightPercentage);
 	if (!iControllerOpen)
 		{
 		User::Leave(KErrNotReady);
 		}
 	CMediaClientVideoDisplayBody* display = CMediaClientVideoDisplayBody::FindDisplayWithWindowL(iActiveDisplays, aWindow);
 	display->SetScaleFactorL(aWindow, aWidthPercentage, aHeightPercentage, iCropRegion);
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetScaleFactorL--");
 	}
 void CVideoPlayerUtility::CBody::GetScaleFactorL(const RWindowBase& aWindow, TReal32& aWidthPercentage, TReal32& aHeightPercentage) const
 	{
 	if (!iControllerOpen)
 	{
 	SetAutoScaleL(aScaleType, EHorizontalAlignCenter, EVerticalAlignCenter);
 	}
 void CVideoPlayerUtility::CBody::SetAutoScaleL(TAutoScaleType aScaleType, TInt aHorizPos, TInt aVertPos)
 	{
-	// Leave if Open is not yet called.
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetAutoScaleL++");
+DEBUG_PRINTF4("CVideoPlayerUtility::CBody::SetAutoScaleL - aScaleType %d, aHorizPos %d, aVertPos %d", aScaleType, aHorizPos, aVertPos);
+// Leave if Open is not yet called.
 	if(!iEventOpenReceived )
 		{
 		User::Leave(KErrNotReady);
 		}
 			}
 		}
 #else
 	User::LeaveIfError(iVideoPlayControllerExtCustomCommands.SetAutoScale(aScaleType, aHorizPos, aVertPos));
 #endif // SYMBIAN_BUILD_GCE
+DEBUG_PRINTF("CVideoPlayerUtility::CBody::SetAutoScaleL--");
 	}
 #ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT
 TBool CVideoPlayerUtility::CBody::SubtitlesAvailable()
 	{

changeset 13	efebd1779a59
parent 0	40261b775718
child 12	b74061f7f3d2