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

equal deleted inserted replaced

-:c1e808730d6c
+:c36d67f77f75
 #include "mediaclientpolicyserverclient.h"
 #include <surfaceeventhandler.h>
 #include <mmf/plugin/mmfmediaclientextdisplayinterface.hrh>
 #include <e32cmn.h>
 #include <ecom/ecom.h>
+#include <centralrepository.h>
+const TUid KCRUidTvoutSettings = {0x1020730B};
+const TUint32 KSettingsTvAspectRatio = 0x00000001;
+#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW
+// make sure that off screen is bottom right and not top left. This makes it more efficient for GCE backend
+// to render
+const TInt KHiddenExtentA = 2000; // rect Ax and Ay co-ordinate used to set extent off screen
+const TInt KHiddenExtentB = 2001; // rect Bx and By co-ordinate used to set extent off screen
+#endif
 CMediaClientVideoDisplayBody* CMediaClientVideoDisplayBody::NewL(TInt aDisplayId, TBool aExtDisplaySwitchingControl)
 	{
 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL +++");
 DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aDisplayId %d", aDisplayId);
 CMediaClientVideoDisplayBody* CMediaClientVideoDisplayBody::NewL(TInt aDisplayId, const TSurfaceId& aSurfaceId,
 		const TRect& aCropRect, TVideoAspectRatio aAspectRatio, TBool aExtDisplaySwitchingControl)
 	{
 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL +++");
 	DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aDisplayId %d", aDisplayId);
-DEBUG_PRINTF5("CMediaClientVideoDisplayBody::NewL - aSurfaceId 0x%X,0x%X,0x%X,0x%X", aSurfaceId.iInternal[0], aSurfaceId.iInternal[1], aSurfaceId.iInternal[2], aSurfaceId.iInternal[3]);
+DEBUG_PRINTF5("CMediaClientVideoDisplayBody::NewL - aSurfaceId %08x:%08x:%08x:%08x", aSurfaceId.iInternal[3], aSurfaceId.iInternal[2], aSurfaceId.iInternal[1], aSurfaceId.iInternal[0]);
 DEBUG_PRINTF5("CMediaClientVideoDisplayBody::NewL - aCropRect %d,%d - %d,%d", aCropRect.iTl.iX, aCropRect.iTl.iY, aCropRect.iBr.iX, aCropRect.iBr.iY);
 DEBUG_PRINTF3("CMediaClientVideoDisplayBody::NewL - aAspectRatio %d/%d", aAspectRatio.iNumerator, aAspectRatio.iDenominator);
 DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aExtDisplaySwitchingControl %d", aExtDisplaySwitchingControl);
 	if(aSurfaceId.IsNull())
 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody +++");
 	// remove for whichever array is current
 	RemoveBackgroundSurface(ETrue);
+#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW
+if(iSwitchedToExternalDisplay)
+{
+SetWindowArrayPtr2Client();
+RemoveBackgroundSurface(ETrue);
+}
+#endif
 	iClientWindows.Close();
 iExtDisplayWindows.Close();
 	delete iExtDisplayHandler;
 	RemoveExtDisplayPlugin();
 {
 TRAPD(err, CreateExtDisplayHandlerL());
 DEBUG_PRINTF2("CMediaClientVideoDisplayBody::AddDisplayWindowL CreateExtDisplayHandlerL error %d", err);
 if(err == KErrNone)
 {
+#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW
+// attach surface to client window and hide
+// ignore error - no handling required
+SetHiddenBackgroundSurfaceOnClientWindow(winData);
+#endif
+// handle external display
 SetWindowArrayPtr2Ext();
 User::LeaveIfError(RedrawWindows(aCropRegion));
 }
 }
 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveDisplayWindow +++");
 	TInt pos = iClientWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);
 	if (pos >= 0)
 	    {
+#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW
+if(IsSurfaceCreated())
+#else
 	    if(IsSurfaceCreated() && !iSwitchedToExternalDisplay)
-{
+#endif
+	        {
 iClientWindows[pos].iWindow->RemoveBackgroundSurface(ETrue);
 // Make sure all window rendering has completed before proceeding
 RWsSession* ws = iClientWindows[pos].iWindow->Session();
 if (ws)
 {
 TInt CMediaClientVideoDisplayBody::SurfaceCreated(const TSurfaceId& aSurfaceId, const TRect& aCropRect, TVideoAspectRatio aAspectRatio, const TRect& aCropRegion)
 	{
 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceCreated +++");
-DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aSurfaceId 0x%X,0x%X,0x%X,0x%X", aSurfaceId.iInternal[0], aSurfaceId.iInternal[1], aSurfaceId.iInternal[2], aSurfaceId.iInternal[3]);
+DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aSurfaceId %08x:%08x:%08x:%08x", aSurfaceId.iInternal[3], aSurfaceId.iInternal[2], aSurfaceId.iInternal[1], aSurfaceId.iInternal[0]);
 DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aCropRect %d,%d - %d,%d", aCropRect.iTl.iX, aCropRect.iTl.iY, aCropRect.iBr.iX, aCropRect.iBr.iY);
 DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SurfaceCreated - aAspectRatio %d/%d", aAspectRatio.iNumerator, aAspectRatio.iDenominator);
 DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);
 TBool emitEvent = EFalse;
 {
 TRAP(err, CreateExtDisplayHandlerL());
 DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SurfaceCreated CreateExtDisplayHandlerL error %d", err);
 if(err == KErrNone)
 {
+#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW
+SetHiddenBackgroundSurfaceOnAllClientWindows();
+#endif
 SetWindowArrayPtr2Ext();
 }
 }
 }
 	}
 void CMediaClientVideoDisplayBody::RemoveBackgroundSurface(TBool aTriggerRedraw)
 	{
 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveBackgroundSurface +++");
+DEBUG_PRINTF5("CMediaClientVideoDisplayBody::RemoveBackgroundSurface - iSurfaceId %08x:%08x:%08x:%08x", iSurfaceId.iInternal[3], iSurfaceId.iInternal[2], iSurfaceId.iInternal[1], iSurfaceId.iInternal[0]);
 	if (IsSurfaceCreated())
 		{
 		RWsSession* ws = NULL;
 		TInt count = iWindowsArrayPtr->Count();
 	}
 void CMediaClientVideoDisplayBody::RemoveSurface(TBool aControllerEvent)
 {
 DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveSurface +++");
+DEBUG_PRINTF5("CMediaClientVideoDisplayBody::RemoveSurface - iSurfaceId %08x:%08x:%08x:%08x", iSurfaceId.iInternal[3], iSurfaceId.iInternal[2], iSurfaceId.iInternal[1], iSurfaceId.iInternal[0]);
 if (IsSurfaceCreated())
 {
 RemoveBackgroundSurface(ETrue);
 if (iEventHandler  && aControllerEvent)
 {
 iEventHandler->MmsehRemoveSurface(iSurfaceId);
 }
+if(iSwitchedToExternalDisplay)
+{
+SetWindowArrayPtr2Client();
+#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW
+RemoveBackgroundSurface(ETrue);
+#endif
+RemoveExtDisplayHandler();
+}
 iSurfaceId = TSurfaceId::CreateNullId();
-if(iSwitchedToExternalDisplay)
-{
-SetWindowArrayPtr2Client();
-RemoveExtDisplayHandler();
-}
 }
 DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveSurface ---");
 }
 TInt CMediaClientVideoDisplayBody::SurfaceParametersChanged(const TSurfaceId& aSurfaceId, const TRect& aCropRect, TVideoAspectRatio aAspectRatio)
 	{
 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceParametersChanged +++");
-DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aSurfaceId 0x%X,0x%X,0x%X,0x%X", aSurfaceId.iInternal[0], aSurfaceId.iInternal[1], aSurfaceId.iInternal[2], aSurfaceId.iInternal[3]);
+DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aSurfaceId %08x:%08x:%08x:%08x", aSurfaceId.iInternal[3], aSurfaceId.iInternal[2], aSurfaceId.iInternal[1], aSurfaceId.iInternal[0]);
 DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aCropRect %d,%d - %d,%d", aCropRect.iTl.iX, aCropRect.iTl.iY, aCropRect.iBr.iX, aCropRect.iBr.iY);
 DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SurfaceCreated - aAspectRatio %d/%d", aAspectRatio.iNumerator, aAspectRatio.iDenominator);
 if (!IsSurfaceCreated())
 		{
 }
 DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - viewport1 %d,%d - %d,%d", viewport.iTl.iX, viewport.iTl.iY, viewport.iBr.iX, viewport.iBr.iY);
 TRect videoExtent(aWindowData.iVideoExtent);
 TReal32 inputWidth = 0.0f;
 TReal32 inputHeight = 0.0f;
 TReal32 pixelAspectRatio = 0.0f;
 switch (aWindowData.iRotation)
 {
 deltaHeight = (TInt) (extent.Width() / viewportAspect - extent.Height());
 }
 }
 else if (aWindowData.iAutoScaleType == EAutoScaleStretch)
 {
-// Don't do anything: the extent is already set to the size of the video extent.
+if(iSwitchedToExternalDisplay)
+{
+UpdateDeltaForExtDisplay(viewportAspect, videoExtent, deltaHeight, deltaWidth);
+}
 }
 else if (aWindowData.iAutoScaleType == EAutoScaleNone)
 {
 // for non-square pixels, reduce one dimension
 // TBD other option is to enlarge in the other dimension
 aWindowData.iSurfaceConfig.SetViewport(viewport);
 aWindowData.iSurfaceConfig.SetExtent(extent);
 aWindowData.iSurfaceConfig.SetOrientation(ConvertRotation(aWindowData.iRotation));
 aWindowData.iSurfaceConfig.SetSurfaceId(iSurfaceId);
+DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - iSurfaceId %08x:%08x:%08x:%08x",
+iSurfaceId.iInternal[3], iSurfaceId.iInternal[2], iSurfaceId.iInternal[1], iSurfaceId.iInternal[0]);
 // Get the rectangle that bounds the crop rectangle and the viewport.  This should be
 // the same as the crop rectangle as long as the viewport does not go outside this area.
 TRect rect(iCropRect);
 rect.BoundingRect(viewport);
 }
 DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetExternalDisplaySwitchingL ---");
 }
-void CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected(TBool aExtDisplayConnected)
+void CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected(TExtDisplayConnectionProviderConnType aExtDisplayConnType)
 	{
-	DEBUG_PRINTF2("CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected +++ aExtDisplayConnected=%d", aExtDisplayConnected);
+	DEBUG_PRINTF2("CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected +++ aExtDisplayConnType=%d", aExtDisplayConnType);
-	if(iExtDisplayConnected != aExtDisplayConnected)
+	if(aExtDisplayConnType != iExtDisplayConnType)
 	    {
-	    iExtDisplayConnected = aExtDisplayConnected;
+TExtDisplayConnectionProviderConnType prevExtDisplayConnType = iExtDisplayConnType;
-SwitchSurface();
+iExtDisplayConnType = aExtDisplayConnType;
+if(prevExtDisplayConnType == EExtDisplayConnectionProviderConnTypeDisconnected)
+{
+// disconnected -> connected  - don't care which type it is
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected disconnected -> connected(type %d)", iExtDisplayConnType);
+iExtDisplayConnected = ETrue;
+SwitchSurface();
+}
+else if(iExtDisplayConnType == EExtDisplayConnectionProviderConnTypeDisconnected)
+{
+// connected -> disconnected  - don't care from which type it is
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected connected(type %d) -> disconnected", prevExtDisplayConnType);
+iExtDisplayConnected = EFalse;
+SwitchSurface();
+}
+else
+{
+// If we get this far then the connection type has changed from "AV Out -> HDMI" or "HDMI -> AV Out"
+// Both are likely. "AV Out -> HDMI" occurs if AV Out cable is connected and HDMI cable is then connected.
+// "HDMI -> AV Out" occurs if both AV Out and HDMI cables are connected and HDMI cable is then disconnected.
+// HDMI is preferred over AV Out.
+// update external display window data
+iExtDisplayHandler->UpdateWindow();
+TRect externalDisplayRect(TPoint(0, 0), iExtDisplayHandler->DisplaySizeInPixels());
+(*iWindowsArrayPtr)[0].iClipRect = externalDisplayRect;
+(*iWindowsArrayPtr)[0].iVideoExtent = externalDisplayRect;
+TRAPD(err, (*iWindowsArrayPtr)[0].iAutoScaleType = ExtDisplayAutoScaleTypeL());
+if(err == KErrNone)
+{
+RemoveBackgroundSurface(ETrue);
+RedrawWindows(iCropRegion);
+}
+else
+{
+// Not a lot we can do. Just keep as it is but external display output will be incorrect.
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected ExtDisplayAutoScaleTypeL failed %d", err);
+}
+}
 	    }
 	else
-	    {
+{
-	    DEBUG_PRINTF("CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected No change in ext display connection status");
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected No change to connection type");
-	    }
+}
 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::MedcpcExtDisplayNotifyConnected ---");
 	}
 void CMediaClientVideoDisplayBody::SetWindowArrayPtr2Client()
 DEBUG_PRINTF2("CMediaClientVideoDisplayBody::CreateExtDisplayHandlerL - iWindow WsHandle 0x%X", windowData.iWindow->WsHandle());
 TRect externalDisplayRect(TPoint(0, 0), extDisplayHandler->DisplaySizeInPixels());
 windowData.iClipRect = externalDisplayRect;
 windowData.iVideoExtent = externalDisplayRect;
-// windowData.iScaleWidth not required for EAutoScaleBestFit
+// windowData.iScaleWidth only required for EAutoScaleNone
-// windowData.iScaleHeight not required for EAutoScaleBestFit
+// windowData.iScaleWidth only required for EAutoScaleNone
 windowData.iRotation = EVideoRotationNone;
-windowData.iAutoScaleType = EAutoScaleBestFit;
+windowData.iAutoScaleType = ExtDisplayAutoScaleTypeL();
 windowData.iHorizPos = EHorizontalAlignCenter;
 windowData.iVertPos = EVerticalAlignCenter;
 // windowData.iWindow2 not used
 iExtDisplayWindows.AppendL(windowData);
 if(iExtDisplayConnectionProvider)
 {
 iExtDisplaySwitchingSupported = ETrue;
 iExtDisplayConnectionProvider->SetExtDisplayConnectionProviderCallback(*this);
-iExtDisplayConnected = iExtDisplayConnectionProvider->ExtDisplayConnected();
+iExtDisplayConnType = iExtDisplayConnectionProvider->ExtDisplayConnType();
+iExtDisplayConnected = (iExtDisplayConnType != EExtDisplayConnectionProviderConnTypeDisconnected);
 }
 DEBUG_PRINTF("CMediaClientVideoDisplayBody::CreateExtDisplayPluginL ---");
 }
 {
 TRAPD(err, CreateExtDisplayHandlerL());
 DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SwitchSurface CreateExtDisplayHandlerL error %d", err);
 if(err == KErrNone)
 {
-// Set background surface for external display window before removing from client windows.
-// Required for switching of paused video
 SetWindowArrayPtr2Ext();
 RedrawWindows(iCropRegion);
+#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW
+// Hide surface so that video is not seen on client window
+HideAllClientWindows();
+#else
+// Surface removed from window
 SetWindowArrayPtr2Client();
 RemoveBackgroundSurface(ETrue);
 SetWindowArrayPtr2Ext();
+#endif
 }
 }
 else if(iSwitchedToExternalDisplay)
 {
 // Set background surface for clientwindows before removing from external display window.
-// Required for switching of paused video
 SetWindowArrayPtr2Client();
+// RedrawWindows handles both the case where the surface was removed from client window and
+// also the case where the surface was hidden from client window
 RedrawWindows(iCropRegion);
 SetWindowArrayPtr2Ext();
 RemoveBackgroundSurface(ETrue);
 RemoveExtDisplayHandler();
 SetWindowArrayPtr2Client();
 	aOldRect.Intersection(aOtherRect);
 	aNewRect.Intersection(aOtherRect);
 	if (aOldRect != aNewRect)
 		{
-		DEBUG_PRINTF("CMediaClientVideoDisplayBody::IntersectionAreaChanged - Intersection area has changed");
+		DEBUG_PRINTF("CMediaClientVideoDisplayBody::IntersectionAreaChanged --- Intersection area has changed");
 		return ETrue;
 		}
-	DEBUG_PRINTF("CMediaClientVideoDisplayBody::IntersectionAreaChanged - Intersection area has not changed");
+	DEBUG_PRINTF("CMediaClientVideoDisplayBody::IntersectionAreaChanged --- Intersection area has not changed");
 	return EFalse;
 	}
+/**
+* This function calculates the delta width and delta height for AV out when the TV-Out setting is set to "widescreen".
+*
+* AV out has fixed resolution whether TV-Out is set to "normal" or "widescreen". The TV-Out setting indicates
+* that the video should be scaled so that when displayed on a corresponding TV the aspect looks correct.
+*
+* When displaying video on a widescreen TV through AV out, because the resolution is the same the TV stretches
+* the video horizontally. When displaying on a normal TV no stretching takes place.
+*
+* For "normal" TAutoScaleType::EAutoScaleClip is used.
+*
+* For "widescreen" this function calculates the width delta and height delta required so that when the video is stretched
+* the aspect looks correct on a widescreen TV.
+*
+* This function must only be called when autoscale is set to TAutoScaleType::EAutoScaleStretch and an external display is
+* connected.
+**/
+void CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay(TReal32 aViewportAspect, const TRect& aVideoExtent, TInt& aDeltaHeight, TInt& aDeltaWidth)
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay +++");
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay aViewportAspect %f", aViewportAspect);
+DEBUG_PRINTF5("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay aVideoExtent %d,%d - %d,%d", aVideoExtent.iTl.iX, aVideoExtent.iTl.iY, aVideoExtent.iBr.iX, aVideoExtent.iBr.iY);
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay aDeltaHeight %d", aDeltaHeight);
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay aDeltaWidth %d", aDeltaWidth);
+aDeltaWidth = 0;
+aDeltaHeight = 0;
+TReal32 wideScreenAspect = (TReal32)16 / (TReal32)9;
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay wideScreenAspect %f", wideScreenAspect);
+if(aViewportAspect == wideScreenAspect)
+{
+// no need to calculate
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay - Viewport Aspect equals wideScreenAspect");
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay - width delta and height delta not changed");
+}
+else if(aViewportAspect < wideScreenAspect)
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay - Viewport Aspect is less than wideScreenAspect");
+// calculate video width for viewport that when stretched looks ok on widescreen
+TReal32 correctedWidth = (TReal32)aVideoExtent.Width() * aViewportAspect / wideScreenAspect;
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay corrected viewport width %f", correctedWidth);
+aDeltaWidth = correctedWidth - aVideoExtent.Width();
+}
+else // aViewportAspect > wideScreenAspect
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay - Viewport Aspect is greater than wideScreenAspect");
+// calculate video height for viewport that when stretched looks ok on widescreen
+TReal32 correctedHeight = (TReal32)aVideoExtent.Height() * wideScreenAspect / aViewportAspect;
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay corrected viewport height %f", correctedHeight);
+aDeltaHeight = aVideoExtent.Height() - correctedHeight;
+}
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay --- aDeltaHeight %d", aDeltaHeight);
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay --- aDeltaWidth %d", aDeltaWidth);
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateDeltaForExtDisplay ---");
+}
+TBool CMediaClientVideoDisplayBody::IsWideScreenL()
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::IsWideScreenL +++");
+CRepository* repo = CRepository::NewLC(KCRUidTvoutSettings);
+TInt value;
+User::LeaveIfError(repo->Get(KSettingsTvAspectRatio, value));
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::IsWideScreenL Tv Apect Ratio set to %d, 0=4x3 1=16x9", value);
+CleanupStack::PopAndDestroy(repo);
+TBool ret = value > 0;
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::IsWideScreenL --- return %d", ret);
+return ret;
+}
+TAutoScaleType CMediaClientVideoDisplayBody::ExtDisplayAutoScaleTypeL()
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::ExtDisplayAutoScaleTypeL +++");
+// EExtDisplayConnectionProviderConnTypeHdmi - EAutoScaleBestFit
+// EExtDisplayConnectionProviderConnTypeAnalog / normal - EAutoScaleBestFit
+// EExtDisplayConnectionProviderConnTypeAnalog / widescreen - EAutoScaleStretch
+TAutoScaleType autoScaleType;
+if((iExtDisplayConnType == EExtDisplayConnectionProviderConnTypeAnalog) && IsWideScreenL())
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::ExtDisplayAutoScaleTypeL External display scale type EAutoScaleStretch");
+autoScaleType = EAutoScaleStretch;
+}
+else
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::ExtDisplayAutoScaleTypeL External display scale type EAutoScaleBestFit");
+autoScaleType = EAutoScaleBestFit;
+}
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::ExtDisplayAutoScaleTypeL --- return %d", autoScaleType);
+return autoScaleType;
+}
+#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW
+void CMediaClientVideoDisplayBody::HideAllClientWindows()
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::HideAllClientWindows +++");
+TInt count = iClientWindows.Count();
+for (TInt i = 0; i < count; ++i)
+{
+// ignore error - cannot be handled
+HideWindow(iClientWindows[i].iWindow);
+}
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::HideAllClientWindows ---");
+}
+TInt CMediaClientVideoDisplayBody::HideWindow(RWindowBase* aWindow)
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::HideWindow +++");
+TSurfaceConfiguration config;
+TInt err = aWindow->GetBackgroundSurface(config);
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::HideWindow GetBackgroundSurface error %d", err);
+#ifdef _DEBUG
+TSurfaceId surface;
+config.GetSurfaceId(surface);
+DEBUG_PRINTF5("CMediaClientVideoDisplayBody::HideWindow - Retrieved Surface %08x:%08x:%08x:%08x",
+surface.iInternal[3], surface.iInternal[2], surface.iInternal[1], surface.iInternal[0]);
+#endif
+if (err == KErrNone)
+{
+config.SetExtent(TRect(KHiddenExtentA, KHiddenExtentA, KHiddenExtentB, KHiddenExtentB));
+err = aWindow->SetBackgroundSurface(config, ETrue);
+// Make sure all window rendering has completed before proceeding
+RWsSession* ws = aWindow->Session();
+if (ws)
+{
+ws->Finish();
+}
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::HideWindow SetBackgroundSurface error %d", err);
+}
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::HideWindow ---");
+return err;
+}
+void CMediaClientVideoDisplayBody::SetHiddenBackgroundSurfaceOnAllClientWindows()
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetHiddenBackgroundSurfaceOnAllClientWindows +++");
+TInt count = iClientWindows.Count();
+for (TInt i = 0; i < count; ++i)
+{
+// ignore error - cannot be handled
+SetHiddenBackgroundSurfaceOnClientWindow(iClientWindows[i]);
+}
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetHiddenBackgroundSurfaceOnAllClientWindows ---");
+}
+TInt CMediaClientVideoDisplayBody::SetHiddenBackgroundSurfaceOnClientWindow(TWindowData& aWindowData)
+{
+DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetHiddenBackgroundSurfaceOnClientWindow +++");
+DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetHiddenBackgroundSurfaceOnClientWindow - iSurfaceId %08x:%08x:%08x:%08x",
+iSurfaceId.iInternal[3], iSurfaceId.iInternal[2], iSurfaceId.iInternal[1], iSurfaceId.iInternal[0]);
+TSurfaceConfiguration config;
+config.SetExtent(TRect(KHiddenExtentA, KHiddenExtentA, KHiddenExtentB, KHiddenExtentB));
+config.SetSurfaceId(iSurfaceId);
+TInt err = aWindowData.iWindow->SetBackgroundSurface(config, ETrue);
+DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetHiddenBackgroundSurfaceOnClientWindow ---, return %d", err);
+return err;
+}
+#endif

changeset 26	c36d67f77f75
parent 15	c1e808730d6c
child 31	ae0addfe117e