1 // Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "mediaclientvideodisplaybody.h"

    17 #include "mediaclientvideotrace.h"

    18 #include "mediaclientpolicyserverclient.h"

    19 #include <surfaceeventhandler.h>

    20 #include <mmf/plugin/mmfmediaclientextdisplayinterface.hrh>

    21 #include <e32cmn.h>

    22 #include <ecom/ecom.h>

    23 #include <centralrepository.h>

    24 

    25 const TUid KCRUidTvoutSettings = {0x1020730B};

    26 const TUint32 KSettingsTvAspectRatio = 0x00000001;

    27 

    28 #ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

    29 // make sure that off screen is bottom right and not top left. This makes it more efficient for GCE backend

    30 // to render

    31 const TInt KHiddenExtentA = 2000; // rect Ax and Ay co-ordinate used to set extent off screen

    32 const TInt KHiddenExtentB = 2001; // rect Bx and By co-ordinate used to set extent off screen

    33 #endif

    34 

    35 CMediaClientVideoDisplayBody* CMediaClientVideoDisplayBody::NewL(TInt aDisplayId, TBool aExtDisplaySwitchingControl)

    36 	{

    37 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL +++");

    38     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aDisplayId %d", aDisplayId);

    39     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aExtDisplaySwitchingControl %d", aExtDisplaySwitchingControl);

    40     

    41     CMediaClientVideoDisplayBody* self = new (ELeave) CMediaClientVideoDisplayBody(aDisplayId);

    42 	CleanupStack::PushL(self);

    43 	self->ConstructL(aExtDisplaySwitchingControl);

    44 	CleanupStack::Pop(self);

    45 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL ---");

    46 	return self;

    47 	}

    48 

    49 CMediaClientVideoDisplayBody* CMediaClientVideoDisplayBody::NewL(TInt aDisplayId, const TSurfaceId& aSurfaceId,

    50 		const TRect& aCropRect, TVideoAspectRatio aAspectRatio, TBool aExtDisplaySwitchingControl)

    51 	{

    52 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL +++");

    53 	DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aDisplayId %d", aDisplayId);

    54     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::NewL - aSurfaceId %08x:%08x:%08x:%08x", aSurfaceId.iInternal[3], aSurfaceId.iInternal[2], aSurfaceId.iInternal[1], aSurfaceId.iInternal[0]);

    55     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::NewL - aCropRect %d,%d - %d,%d", aCropRect.iTl.iX, aCropRect.iTl.iY, aCropRect.iBr.iX, aCropRect.iBr.iY);

    56     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::NewL - aAspectRatio %d/%d", aAspectRatio.iNumerator, aAspectRatio.iDenominator);

    57     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aExtDisplaySwitchingControl %d", aExtDisplaySwitchingControl);

    58 

    59 	if(aSurfaceId.IsNull())

    60 		{

    61 		User::Leave(KErrArgument);

    62 		}

    63 	CMediaClientVideoDisplayBody* self = new(ELeave) CMediaClientVideoDisplayBody(aDisplayId, aSurfaceId, aCropRect, aAspectRatio);

    64 	CleanupStack::PushL(self);

    65 	self->ConstructL(aExtDisplaySwitchingControl);

    66 	CleanupStack::Pop();

    67 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL ---");

    68 	return self;

    69 	}

    70 

    71 void CMediaClientVideoDisplayBody::ConstructL(TBool aExtDisplaySwitchingControl)

    72 	{

    73 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::ConstructL +++");

    74 

    75 	SetWindowArrayPtr2Client();

    76 

    77 	// External display switching and wserv events are only possible if there is

    78 	// an active scheduler in client thread

    79 	if(CActiveScheduler::Current())

    80 	    {

    81         CreateExtDisplayPluginL();

    82         iWsEventObserver = CMediaClientWsEventObserver::NewL(*this);

    83 

    84         iServerClient = CMediaClientPolicyServerClient::NewL();

    85         if(iServerClient->Connect() != KErrNone)

    86             {

    87             delete iServerClient;

    88             iServerClient = NULL;

    89             }

    90         

    91         if(IsSurfaceCreated() && iServerClient)

    92             {

    93             iServerClient->SetSurface(iSurfaceId);

    94             }

    95         

    96         // Try and enable display switching by default. If this leaves then do so quietly.

    97         // Either the client has no scheduler installed or the device does not support external

    98         // switching (i.e. no plugin was found) 

    99         TRAPD(err, SetExternalDisplaySwitchingL(aExtDisplaySwitchingControl));

   100         err = err; // remove compile warning

   101         DEBUG_PRINTF2("CMediaClientVideoDisplayBody::ConstructL SetExternalDisplaySwitchingL returned with %d", err);

   102 	    }

   103 	else

   104 	    {

   105 	    DEBUG_PRINTF("CMediaClientVideoDisplayBody::ConstructL No CActiveScheduler - ext display and focus features disabled ");

   106 	    }

   107 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::ConstructL ---");

   108 	}

   109 

   110 CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody(TInt aDisplayId, const TSurfaceId& aSurfaceId,

   111 		const TRect& aCropRect, TVideoAspectRatio aAspectRatio) :

   112 	iDisplayId(aDisplayId),

   113 	iSurfaceId(aSurfaceId),

   114 	iCropRect(aCropRect),

   115 	iAspectRatio(aAspectRatio)

   116 	{	

   117 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody +++");

   118 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody ---");

   119 	}

   120 

   121 CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody(TInt aDisplayId) :

   122 	iDisplayId(aDisplayId)

   123 	{	

   124 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody +++");

   125 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody ---");

   126 	}

   127 

   128 CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody()

   129 	{

   130 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody +++");

   131 

   132 	// remove for whichever array is current

   133 	RemoveBackgroundSurface(ETrue);

   134 

   135 #ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

   136     if(iSwitchedToExternalDisplay)

   137         {

   138         SetWindowArrayPtr2Client();

   139         RemoveBackgroundSurface(ETrue);

   140         }

   141 #endif

   142 

   143 	iClientWindows.Close();	

   144     iExtDisplayWindows.Close(); 

   145 

   146 	delete iExtDisplayHandler;

   147 	RemoveExtDisplayPlugin();

   148 	REComSession::FinalClose();

   149 	

   150     delete iWsEventObserver;

   151 

   152     delete iServerClient;

   153     

   154 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody ---");

   155 	}

   156 

   157 void CMediaClientVideoDisplayBody::AddDisplayL(MMMFSurfaceEventHandler& aEventHandler)

   158 	{

   159 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::AddDisplayL +++");

   160 	if (iEventHandler)

   161 		{

   162 		User::Leave(KErrInUse);

   163 		}

   164 		

   165 	iEventHandler = &aEventHandler;

   166 	

   167 	if (IsSurfaceCreated())

   168 		{

   169 		iEventHandler->MmsehSurfaceCreated(iDisplayId, iSurfaceId, iCropRect, iAspectRatio);

   170 		}

   171 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::AddDisplayL ---");

   172 	}

   173 	

   174 void CMediaClientVideoDisplayBody::AddDisplayWindowL(const RWindowBase* aWindow, const TRect& aClipRect, const TRect& aCropRegion, const TRect& aVideoExtent, 

   175 															TReal32 aScaleWidth, TReal32 aScaleHeight, TVideoRotation aRotation, 

   176 															TAutoScaleType aAutoScaleType, TInt aHorizPos, TInt aVertPos, RWindow* aWindow2)

   177 	{	

   178 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::AddDisplayWindowL +++");

   179     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::AddDisplayWindowL - aWindow WsHandle 0x%X", aWindow->WsHandle());

   180     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::AddDisplayWindowL - aClipRect %d,%d - %d,%d", aClipRect.iTl.iX, aClipRect.iTl.iY, aClipRect.iBr.iX, aClipRect.iBr.iY);

   181     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::AddDisplayWindowL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   182     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::AddDisplayWindowL - aVideoExtent %d,%d - %d,%d", aVideoExtent.iTl.iX, aVideoExtent.iTl.iY, aVideoExtent.iBr.iX, aVideoExtent.iBr.iY);

   183     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::AddDisplayWindowL - aScaleWidth %f, aScaleHeight %f", aScaleWidth, aScaleHeight);

   184     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::AddDisplayWindowL - aRotation %d", aRotation);

   185     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::AddDisplayWindowL - aAutoScaleType %d", aAutoScaleType);

   186     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::AddDisplayWindowL - aHorizPos %d, aVertPos %d", aHorizPos, aVertPos);

   187 

   188 	if (!IsRotationValid(aRotation))

   189 		{

   190 		User::Leave(KErrArgument);

   191 		}

   192 

   193 	if (!IsAutoScaleTypeValid(aAutoScaleType))

   194 		{

   195 		User::Leave(KErrArgument);

   196 		}

   197 

   198 	TInt pos = iClientWindows.Find(aWindow->WsHandle(), TWindowData::CompareByWsHandle);

   199 	

   200 	if (pos != KErrNotFound)

   201 		{

   202 		User::Leave(KErrInUse);

   203 		}

   204 	

   205 	TWindowData winData(aWindow, aClipRect, aVideoExtent, aScaleWidth, aScaleHeight, aRotation, aAutoScaleType, aHorizPos, aVertPos, aWindow2);

   206 	iClientWindows.AppendL(winData);

   207 	

   208 	iCropRegion = aCropRegion;

   209 	

   210 	TBool prevClientWindowIsInFocus = iClientWindowIsInFocus;

   211     UpdateFocus();

   212 	

   213 	if (IsSurfaceCreated())

   214 		{

   215         // if first window was just added OR the new window has moved us from out of focus to in focus

   216         if(((iClientWindows.Count() == 1) || !prevClientWindowIsInFocus) && iClientRequestedExtDisplaySwitching &&

   217                 iClientWindowIsInFocus && iExtDisplayConnected)

   218             {

   219             TRAPD(err, CreateExtDisplayHandlerL());

   220             DEBUG_PRINTF2("CMediaClientVideoDisplayBody::AddDisplayWindowL CreateExtDisplayHandlerL error %d", err);

   221             if(err == KErrNone)

   222                 {

   223 #ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

   224                 // attach surface to client window and hide

   225                 // ignore error - no handling required

   226                 SetHiddenBackgroundSurfaceOnClientWindow(winData);

   227 #endif                

   228                 // handle external display

   229                 SetWindowArrayPtr2Ext();

   230                 User::LeaveIfError(RedrawWindows(aCropRegion));

   231                 }

   232             }

   233         

   234         if(!iSwitchedToExternalDisplay)

   235             {

   236             User::LeaveIfError(SetBackgroundSurface(winData, aCropRegion));

   237             }

   238 		}

   239 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::AddDisplayWindowL ---");

   240 	}

   241 

   242 void CMediaClientVideoDisplayBody::UpdateDisplayWindowL(const RWindowBase* aWindow, const TRect& aClipRect, const TRect& aCropRegion, const TRect& aVideoExtent, 

   243                                                             TReal32 aScaleWidth, TReal32 aScaleHeight, TVideoRotation aRotation, 

   244                                                             TAutoScaleType aAutoScaleType, TInt aHorizPos, TInt aVertPos, RWindow* aWindow2)

   245     {   

   246     DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateDisplayWindowL +++");

   247     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDisplayWindowL - aWindow WsHandle 0x%X", aWindow->WsHandle());

   248     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::UpdateDisplayWindowL - aClipRect %d,%d - %d,%d", aClipRect.iTl.iX, aClipRect.iTl.iY, aClipRect.iBr.iX, aClipRect.iBr.iY);

   249     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::UpdateDisplayWindowL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   250     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::UpdateDisplayWindowL - aVideoExtent %d,%d - %d,%d", aVideoExtent.iTl.iX, aVideoExtent.iTl.iY, aVideoExtent.iBr.iX, aVideoExtent.iBr.iY);

   251     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::UpdateDisplayWindowL - aScaleWidth %f, aScaleHeight %f", aScaleWidth, aScaleHeight);

   252     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDisplayWindowL - aRotation %d", aRotation);

   253     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::UpdateDisplayWindowL - aAutoScaleType %d", aAutoScaleType);

   254     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::UpdateDisplayWindowL - aHorizPos %d, aVertPos %d", aHorizPos, aVertPos);

   255 

   256     if (!IsRotationValid(aRotation))

   257         {

   258         User::Leave(KErrArgument);

   259         }

   260 

   261     if (!IsAutoScaleTypeValid(aAutoScaleType))

   262         {

   263         User::Leave(KErrArgument);

   264         }

   265 

   266     TInt pos = iClientWindows.Find(aWindow->WsHandle(), TWindowData::CompareByWsHandle);

   267     User::LeaveIfError(pos);

   268     iClientWindows.Remove(pos);

   269     

   270     TWindowData winData(aWindow, aClipRect, aVideoExtent, aScaleWidth, aScaleHeight, aRotation, aAutoScaleType, aHorizPos, aVertPos, aWindow2);

   271     iClientWindows.AppendL(winData);

   272     

   273     TRect prevCropRegion = iCropRegion;

   274     iCropRegion = aCropRegion;

   275     

   276     if (IsSurfaceCreated())

   277         {

   278         if(ClientCropRegionChangeRequiresRedraw(prevCropRegion, aCropRegion, iCropRect))

   279             {

   280             // all windows need to be redrawn

   281             User::LeaveIfError(RedrawWindows(aCropRegion));

   282             }

   283         else

   284             {

   285             // only redraw affected window as other window data may have changed

   286             if(!iSwitchedToExternalDisplay)

   287                 {

   288                 User::LeaveIfError(SetBackgroundSurface(winData, aCropRegion));

   289                 }

   290             }

   291         }

   292 

   293     DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateDisplayWindowL ---");

   294     }

   295 

   296 void CMediaClientVideoDisplayBody::RemoveDisplay()

   297 	{

   298 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveDisplay +++");

   299 	iEventHandler = NULL;

   300 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveDisplay ---");

   301 	}	

   302 

   303 TInt CMediaClientVideoDisplayBody::RemoveDisplayWindow(const RWindowBase& aWindow)

   304 	{

   305 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveDisplayWindow +++");

   306 	TInt pos = iClientWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

   307 	

   308 	if (pos >= 0)

   309 	    {

   310 #ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

   311         if(IsSurfaceCreated())

   312 #else

   313 	    if(IsSurfaceCreated() && !iSwitchedToExternalDisplay)

   314 #endif

   315 	        {

   316             iClientWindows[pos].iWindow->RemoveBackgroundSurface(ETrue);

   317             // Make sure all window rendering has completed before proceeding

   318             RWsSession* ws = iClientWindows[pos].iWindow->Session();

   319             if (ws)

   320                 {

   321                 ws->Finish();

   322                 }

   323             }

   324 

   325 	    iClientWindows.Remove(pos);

   326 	    

   327 	    TBool prevClientWindowIsInFocus = iClientWindowIsInFocus;

   328         UpdateFocus();

   329 

   330         // if only window was just removed OR removal has moved us from in focus to out of focus

   331         if((iClientWindows.Count() == 0 || prevClientWindowIsInFocus) && iSwitchedToExternalDisplay &&

   332                 !iClientWindowIsInFocus)

   333             {

   334             RemoveBackgroundSurface(ETrue);

   335             SetWindowArrayPtr2Client();

   336             RemoveExtDisplayHandler();

   337             RedrawWindows(iCropRegion);

   338             }

   339 		}

   340 	

   341 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveDisplayWindow ---");

   342 	return pos;

   343 	}

   344 

   345 

   346 TInt CMediaClientVideoDisplayBody::SurfaceCreated(const TSurfaceId& aSurfaceId, const TRect& aCropRect, TVideoAspectRatio aAspectRatio, const TRect& aCropRegion)

   347 	{

   348 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceCreated +++");

   349     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aSurfaceId %08x:%08x:%08x:%08x", aSurfaceId.iInternal[3], aSurfaceId.iInternal[2], aSurfaceId.iInternal[1], aSurfaceId.iInternal[0]);

   350     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aCropRect %d,%d - %d,%d", aCropRect.iTl.iX, aCropRect.iTl.iY, aCropRect.iBr.iX, aCropRect.iBr.iY);

   351     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SurfaceCreated - aAspectRatio %d/%d", aAspectRatio.iNumerator, aAspectRatio.iDenominator);

   352     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   353 

   354     TBool emitEvent = EFalse;

   355 	if((iSurfaceId != aSurfaceId) && (!aSurfaceId.IsNull()))

   356 		{

   357 		emitEvent = ETrue;

   358 		}

   359 

   360 	iSurfaceId = aSurfaceId;

   361 	iCropRect = aCropRect;

   362 	iAspectRatio = aAspectRatio;

   363 	iCropRegion = aCropRegion;

   364 	

   365 	if(iServerClient)

   366 	    {

   367         iServerClient->SetSurface(iSurfaceId);

   368 	    }

   369 	

   370 	if (emitEvent && iEventHandler)

   371 		{

   372 		iEventHandler->MmsehSurfaceCreated(iDisplayId, iSurfaceId, iCropRect, iAspectRatio);

   373 		}

   374 

   375 	TInt err = KErrNone;

   376     if((iClientWindows.Count() > 0) && iClientRequestedExtDisplaySwitching && iClientWindowIsInFocus)

   377         {

   378         if(iExtDisplayConnected && !iExtDisplayHandler)

   379             {

   380             TRAP(err, CreateExtDisplayHandlerL());

   381             DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SurfaceCreated CreateExtDisplayHandlerL error %d", err);

   382             if(err == KErrNone)

   383                 {

   384 #ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

   385                 SetHiddenBackgroundSurfaceOnAllClientWindows();

   386 #endif          

   387                 SetWindowArrayPtr2Ext();

   388                 }

   389             }

   390         }

   391     

   392     err = RedrawWindows(aCropRegion);

   393     

   394     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SurfaceCreated --- Return error %d", err);

   395 	return err;

   396 	}

   397 

   398 void CMediaClientVideoDisplayBody::RemoveBackgroundSurface(TBool aTriggerRedraw)

   399 	{

   400 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveBackgroundSurface +++");

   401     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::RemoveBackgroundSurface - iSurfaceId %08x:%08x:%08x:%08x", iSurfaceId.iInternal[3], iSurfaceId.iInternal[2], iSurfaceId.iInternal[1], iSurfaceId.iInternal[0]);

   402 

   403 	if (IsSurfaceCreated())

   404 		{

   405 		RWsSession* ws = NULL;

   406 		TInt count = iWindowsArrayPtr->Count();

   407 	

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

   409 			{

   410 			(*iWindowsArrayPtr)[i].iWindow->RemoveBackgroundSurface(aTriggerRedraw);

   411             // Make sure all window rendering has completed before proceeding

   412             ws = (*iWindowsArrayPtr)[i].iWindow->Session();

   413             if (ws)

   414                 {

   415                 ws->Finish();

   416                 }

   417 			}

   418 		}

   419 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveBackgroundSurface ---");

   420 	}

   421 

   422 void CMediaClientVideoDisplayBody::RemoveSurface(TBool aControllerEvent)

   423     {

   424     DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveSurface +++");

   425     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::RemoveSurface - iSurfaceId %08x:%08x:%08x:%08x", iSurfaceId.iInternal[3], iSurfaceId.iInternal[2], iSurfaceId.iInternal[1], iSurfaceId.iInternal[0]);

   426 

   427     if (IsSurfaceCreated())

   428         {

   429         RemoveBackgroundSurface(ETrue);

   430 

   431         if (iEventHandler  && aControllerEvent)

   432             {

   433             iEventHandler->MmsehRemoveSurface(iSurfaceId);

   434             }

   435 

   436         if(iSwitchedToExternalDisplay)

   437             {

   438             SetWindowArrayPtr2Client();

   439 #ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

   440             RemoveBackgroundSurface(ETrue);

   441 #endif

   442             RemoveExtDisplayHandler();

   443             }

   444         iSurfaceId = TSurfaceId::CreateNullId();

   445         }

   446     

   447     DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveSurface ---");

   448     }

   449 

   450 TInt CMediaClientVideoDisplayBody::SurfaceParametersChanged(const TSurfaceId& aSurfaceId, const TRect& aCropRect, TVideoAspectRatio aAspectRatio)

   451 	{

   452 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceParametersChanged +++");

   453     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aSurfaceId %08x:%08x:%08x:%08x", aSurfaceId.iInternal[3], aSurfaceId.iInternal[2], aSurfaceId.iInternal[1], aSurfaceId.iInternal[0]);

   454     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aCropRect %d,%d - %d,%d", aCropRect.iTl.iX, aCropRect.iTl.iY, aCropRect.iBr.iX, aCropRect.iBr.iY);

   455     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SurfaceCreated - aAspectRatio %d/%d", aAspectRatio.iNumerator, aAspectRatio.iDenominator);

   456 

   457     if (!IsSurfaceCreated())

   458 		{

   459 		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceParametersChanged --- Return error KErrNotSupproted");

   460 		return KErrNotSupported;

   461 		}

   462 

   463 	if (iSurfaceId != aSurfaceId)

   464 		{

   465 		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceParametersChanged --- Return error KErrInUse");

   466 		return KErrInUse;

   467 		}

   468 

   469 	if (iEventHandler)

   470 		{

   471 		iEventHandler->MmsehSurfaceParametersChanged(iSurfaceId, aCropRect, aAspectRatio);

   472 		}

   473 

   474 	TInt error = KErrNone;

   475 	if (iCropRect != aCropRect || iAspectRatio != aAspectRatio)

   476 		{

   477 		// We only need to redraw if the aspect ratio has changed, or the area of the video to

   478 		// display (i.e the intersection of client crop region and surface crop rectangle) has changed.

   479 		TBool redraw = EFalse;

   480 		if (iAspectRatio != aAspectRatio || SurfaceCropRectChangeRequiresRedraw(iCropRect, aCropRect, iCropRegion))

   481 			{

   482 			redraw = ETrue;

   483 			}

   484 

   485 		iCropRect = aCropRect;

   486 		iAspectRatio = aAspectRatio;

   487 

   488 		if (redraw)

   489 			{

   490 			error = RedrawWindows(iCropRegion);

   491 			}

   492 		}

   493 	else

   494 		{

   495 		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceParametersChanged - Surface parameters have not changed");

   496 		}

   497 

   498 	DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SurfaceParametersChanged --- Return error %d", error);

   499 	return error;

   500 	}

   501 	

   502 TInt CMediaClientVideoDisplayBody::RedrawWindows(const TRect& aCropRegion)

   503 	{

   504 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RedrawWindows +++");

   505 	TInt err = KErrNone;	

   506 

   507 	iCropRegion = aCropRegion;

   508 	

   509 	if(IsSurfaceCreated())

   510 		{

   511 		TInt count = iWindowsArrayPtr->Count();

   512 	

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

   514 			{

   515 			err = SetBackgroundSurface((*iWindowsArrayPtr)[i], aCropRegion);

   516 		

   517 			if (err != KErrNone)

   518 				{

   519 				break;

   520 				}

   521 			}

   522 		}

   523 		

   524 	DEBUG_PRINTF2("CMediaClientVideoDisplayBody::RedrawWindows --- return with %d", err);

   525 	return err;

   526 	}

   527 

   528 void CMediaClientVideoDisplayBody::UpdateCropRegionL(const TRect& aCropRegion, TInt aPos, TBool aRedrawIndividualWindow)

   529     {

   530     DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateCropRegionL +++");

   531 

   532     TRect prevCropRegion(iCropRegion);

   533     iCropRegion = aCropRegion;

   534     

   535     if (IsSurfaceCreated())

   536         {

   537         if(prevCropRegion == aCropRegion)

   538             {

   539             if(!iSwitchedToExternalDisplay && aRedrawIndividualWindow)

   540                 {

   541                 User::LeaveIfError(SetBackgroundSurface(iClientWindows[aPos], aCropRegion));

   542                 }

   543             }

   544         else

   545             {

   546 			// We only need to redraw if the area of the video to display (i.e the

   547 			// intersection of client crop region and surface crop rectangle) has changed.

   548 			if (ClientCropRegionChangeRequiresRedraw(prevCropRegion, aCropRegion, iCropRect))

   549 				{

   550 				User::LeaveIfError(RedrawWindows(aCropRegion));

   551 				}

   552             }

   553         }

   554     DEBUG_PRINTF("CMediaClientVideoDisplayBody::UpdateCropRegionL ---");    

   555     }

   556 

   557 void CMediaClientVideoDisplayBody::SetAutoScaleL(const RWindowBase& aWindow, TAutoScaleType aScaleType, TInt aHorizPos, TInt aVertPos, const TRect& aCropRegion)

   558 	{

   559 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetAutoScaleL +++");

   560     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetAutoScaleL - aWindow WsHandle 0x%X", aWindow.WsHandle());

   561     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetAutoScaleL - aScaleType %d", aScaleType);

   562     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SetAutoScaleL - aHorizPos %d, aVertPos %d", aHorizPos, aVertPos);

   563     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetAutoScaleL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   564 

   565 	if (!IsAutoScaleTypeValid(aScaleType))

   566 		{

   567 		User::Leave(KErrArgument);

   568 		}

   569 

   570     TInt pos = iClientWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

   571 	User::LeaveIfError(pos);

   572 

   573 	TBool parameterChanged = EFalse;

   574 	if (aScaleType != iClientWindows[pos].iAutoScaleType || aHorizPos != iClientWindows[pos].iHorizPos || aVertPos != iClientWindows[pos].iVertPos)

   575 		{

   576 		iClientWindows[pos].iAutoScaleType = aScaleType;

   577 		iClientWindows[pos].iHorizPos = aHorizPos;

   578 		iClientWindows[pos].iVertPos = aVertPos;

   579 		parameterChanged = ETrue;

   580 		}

   581 	else

   582 		{

   583 		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetAutoScaleL - Scale parameters have not changed");

   584 		}

   585 

   586 	UpdateCropRegionL(aCropRegion, pos, parameterChanged);

   587 

   588 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetAutoScaleL ---");

   589 	}

   590 	

   591 

   592 void CMediaClientVideoDisplayBody::SetRotationL(const RWindowBase& aWindow, TVideoRotation aRotation, const TRect& aCropRegion)

   593 	{

   594 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetRotationL +++");

   595     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetRotationL - aWindow WsHandle 0x%X", aWindow.WsHandle());

   596     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetRotationL - aRotation %d", aRotation);

   597     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetRotationL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   598 

   599 	if (!IsRotationValid(aRotation))

   600 		{

   601 		User::Leave(KErrArgument);

   602 		}

   603 

   604     TInt pos = iClientWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

   605 	User::LeaveIfError(pos);

   606 

   607 	TBool parameterChanged = EFalse;

   608 	if (aRotation != iClientWindows[pos].iRotation)

   609 		{

   610 		iClientWindows[pos].iRotation = aRotation;

   611 		parameterChanged = ETrue;

   612 		}

   613 	else

   614 		{

   615 		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetRotationL - Rotation has not changed");

   616 		}

   617 

   618     UpdateCropRegionL(aCropRegion, pos, parameterChanged);

   619 

   620 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetRotationL ---");

   621 	}

   622 

   623 TVideoRotation CMediaClientVideoDisplayBody::RotationL(const RWindowBase& aWindow)

   624 	{

   625 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RotationL +++");

   626 	TInt pos = iClientWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

   627 	User::LeaveIfError(pos);

   628 	

   629 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RotationL ---");

   630 	return iClientWindows[pos].iRotation;

   631 	}

   632 

   633 void CMediaClientVideoDisplayBody::SetScaleFactorL(const RWindowBase& aWindow, TReal32 aWidthPercentage, TReal32 aHeightPercentage, const TRect& aCropRegion)

   634 	{

   635 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetScaleFactorL +++");

   636     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetScaleFactorL - aWindow WsHandle 0x%X", aWindow.WsHandle());

   637     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SetScaleFactorL - aWidthPercentage %f, aHeightPercentage %f", aWidthPercentage, aHeightPercentage);

   638     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetScaleFactorL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   639 

   640     TInt pos = iClientWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

   641 	User::LeaveIfError(pos);

   642 	

   643 	if (aWidthPercentage <= 0.0 || aHeightPercentage <= 0.0)

   644 		{

   645 		User::Leave(KErrArgument);

   646 		}

   647 

   648 	TBool parameterChanged = EFalse;

   649 	if (aWidthPercentage != iClientWindows[pos].iScaleWidth ||

   650 	    aHeightPercentage != iClientWindows[pos].iScaleHeight ||

   651 		EAutoScaleNone != iClientWindows[pos].iAutoScaleType)

   652 		{

   653 		iClientWindows[pos].iScaleWidth = aWidthPercentage;

   654 		iClientWindows[pos].iScaleHeight = aHeightPercentage;

   655 		iClientWindows[pos].iAutoScaleType = EAutoScaleNone;

   656 		parameterChanged = ETrue;

   657 		}

   658 	else

   659 		{

   660 		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetScaleFactorL - Scale parameters have not changed");

   661 		}

   662 

   663     UpdateCropRegionL(aCropRegion, pos, parameterChanged);

   664 	

   665     DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetScaleFactorL ---");

   666 	}

   667 	

   668 void CMediaClientVideoDisplayBody::GetScaleFactorL(const RWindowBase& aWindow, TReal32& aWidthPercentage, TReal32& aHeightPercentage)

   669 	{

   670 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::GetScaleFactorL +++");

   671 	TInt pos = iClientWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

   672 	User::LeaveIfError(pos);

   673 	

   674 	aWidthPercentage = iClientWindows[pos].iScaleWidth;

   675 	aHeightPercentage = iClientWindows[pos].iScaleHeight;

   676 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::GetScaleFactorL ---");

   677 	}

   678 

   679 void CMediaClientVideoDisplayBody::SetAutoScaleL(TAutoScaleType aScaleType, TInt aHorizPos, TInt aVertPos, const TRect& aCropRegion)

   680 	{

   681 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetAutoScaleL +++");

   682     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetAutoScaleL - aScaleType %d", aScaleType);

   683     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SetAutoScaleL - aHorizPos %d, aVertPos %d", aHorizPos, aVertPos);

   684     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetAutoScaleL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   685 

   686 	if (!IsAutoScaleTypeValid(aScaleType))

   687 		{

   688 		User::Leave(KErrArgument);

   689 		}

   690 

   691     TRect prevCropRegion(iCropRegion);

   692 	iCropRegion = aCropRegion;

   693 	

   694 	TBool parameterChanged;

   695 	TInt count = iClientWindows.Count();

   696 

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

   698 		{

   699 		parameterChanged = EFalse;

   700 		if (aScaleType != iClientWindows[i].iAutoScaleType || aHorizPos != iClientWindows[i].iHorizPos || aVertPos != iClientWindows[i].iVertPos)

   701 			{

   702 			iClientWindows[i].iAutoScaleType = aScaleType;

   703 			iClientWindows[i].iHorizPos = aHorizPos;

   704 			iClientWindows[i].iVertPos = aVertPos;

   705 			parameterChanged = ETrue;

   706 			}

   707 		else

   708 			{

   709 			DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetAutoScaleL - Scale parameters for window pos %d have not changed", i);

   710 			}

   711 

   712 		// We only need to redraw if the scale parameters have changed, or the area of the video

   713 		// to display (i.e the intersection of client crop region and surface crop rectangle) has changed.

   714 		if (IsSurfaceCreated() && !iSwitchedToExternalDisplay && (parameterChanged || ClientCropRegionChangeRequiresRedraw(prevCropRegion, aCropRegion, iCropRect)))

   715 			{

   716 			User::LeaveIfError(SetBackgroundSurface(iClientWindows[i], aCropRegion));

   717 			}

   718 		}

   719 

   720 	// We only need to redraw if the area of the video to display (i.e the

   721 	// intersection of client crop region and surface crop rectangle) has changed.

   722 	if (IsSurfaceCreated() && iSwitchedToExternalDisplay && ClientCropRegionChangeRequiresRedraw(prevCropRegion, aCropRegion, iCropRect))

   723         {

   724         User::LeaveIfError(RedrawWindows(aCropRegion));

   725         }

   726 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetAutoScaleL ---");

   727 	}

   728 

   729 

   730 void CMediaClientVideoDisplayBody::SetRotationL(TVideoRotation aRotation, const TRect& aCropRegion)

   731 	{

   732 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetRotationL +++");

   733     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetRotationL - aRotation %d", aRotation);

   734     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetRotationL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   735 

   736 	if (!IsRotationValid(aRotation))

   737 		{

   738 		User::Leave(KErrArgument);

   739 		}

   740 

   741     TRect prevCropRegion(iCropRegion);

   742     iCropRegion = aCropRegion;

   743 

   744 	TBool parameterChanged;

   745 	TInt count = iClientWindows.Count();

   746 	

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

   748 		{

   749 		parameterChanged = EFalse;

   750 		if (aRotation != iClientWindows[i].iRotation)

   751 			{

   752 			iClientWindows[i].iRotation = aRotation;

   753 			parameterChanged = ETrue;

   754 			}

   755 		else

   756 			{

   757 			DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetRotationL - Rotation for window pos %d has not changed", i);

   758 			}

   759 

   760 		// We only need to redraw if the scale parameters have changed, or the area of the video

   761 		// to display (i.e the intersection of client crop region and surface crop rectangle) has changed.

   762 		if (IsSurfaceCreated() && !iSwitchedToExternalDisplay && (parameterChanged || ClientCropRegionChangeRequiresRedraw(prevCropRegion, aCropRegion, iCropRect)))

   763 			{

   764 			User::LeaveIfError(SetBackgroundSurface(iClientWindows[i], aCropRegion));

   765 			}

   766 		}

   767 	

   768 	// We only need to redraw if the area of the video to display (i.e the

   769 	// intersection of client crop region and surface crop rectangle) has changed.

   770 	if (IsSurfaceCreated() && iSwitchedToExternalDisplay && ClientCropRegionChangeRequiresRedraw(prevCropRegion, aCropRegion, iCropRect))

   771         {

   772         User::LeaveIfError(RedrawWindows(aCropRegion));

   773         }

   774 	   

   775 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetRotationL ---");

   776 	}

   777 		

   778 void CMediaClientVideoDisplayBody::SetScaleFactorL(TReal32 aWidthPercentage, TReal32 aHeightPercentage, const TRect& aCropRegion)

   779 	{

   780 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetScaleFactorL +++");

   781     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SetScaleFactorL - aWidthPercentage %f, aHeightPercentage %f", aWidthPercentage, aHeightPercentage);

   782     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetScaleFactorL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   783 

   784     if (aWidthPercentage <= 0.0 || aHeightPercentage <= 0.0)

   785 		{

   786 		User::Leave(KErrArgument);

   787 		}

   788 	

   789     TRect prevCropRegion(iCropRegion);

   790 	iCropRegion = aCropRegion;

   791 

   792 	TBool parameterChanged;

   793 	TInt count = iClientWindows.Count();

   794 	

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

   796 		{

   797 		parameterChanged = EFalse;

   798 		

   799 		if (aWidthPercentage != iClientWindows[i].iScaleWidth ||

   800 		    aHeightPercentage != iClientWindows[i].iScaleHeight ||

   801 			EAutoScaleNone != iClientWindows[i].iAutoScaleType)

   802 			{

   803 			iClientWindows[i].iScaleWidth = aWidthPercentage;

   804 			iClientWindows[i].iScaleHeight = aHeightPercentage;

   805 			iClientWindows[i].iAutoScaleType = EAutoScaleNone;

   806 			parameterChanged = ETrue;

   807 			}

   808 		else

   809 			{

   810 			DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetScaleFactorL - Scale parameters for window pos %d have not changed", i);

   811 			}

   812 

   813 		// We only need to redraw if the scale parameters have changed, or the area of the video to

   814 		// display (i.e the intersection of client crop region and surface crop rectangle) has changed.

   815 		if (IsSurfaceCreated() && !iSwitchedToExternalDisplay && (parameterChanged || ClientCropRegionChangeRequiresRedraw(prevCropRegion, aCropRegion, iCropRect)))

   816 			{

   817 			User::LeaveIfError(SetBackgroundSurface(iClientWindows[i], aCropRegion));

   818 			}

   819 		}

   820 

   821 	// We only need to redraw if the area of the video to display (i.e the

   822 	// intersection of client crop region and surface crop rectangle) has changed.

   823 	if (IsSurfaceCreated() && iSwitchedToExternalDisplay && ClientCropRegionChangeRequiresRedraw(prevCropRegion, aCropRegion, iCropRect))

   824         {

   825         User::LeaveIfError(RedrawWindows(aCropRegion));

   826         }

   827 	   

   828 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetScaleFactorL ---");

   829 	}

   830 

   831 void CMediaClientVideoDisplayBody::SetWindowClipRectL(const RWindowBase& aWindow, const TRect& aWindowClipRect, const TRect& aCropRegion)

   832 	{

   833 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetWindowClipRectL +++");

   834     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetWindowClipRectL - aWindow WsHandle 0x%X", aWindow.WsHandle());

   835     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetWindowClipRectL - aWindowClipRect %d,%d - %d,%d", aWindowClipRect.iTl.iX, aWindowClipRect.iTl.iY, aWindowClipRect.iBr.iX, aWindowClipRect.iBr.iY);

   836     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetWindowClipRectL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   837 	

   838 	TInt pos = iClientWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

   839 	User::LeaveIfError(pos);

   840 

   841 	TBool parameterChanged = EFalse;

   842 	if (aWindowClipRect != iClientWindows[pos].iClipRect)

   843 		{

   844 		// We only want to redraw if the change in the clipping rectangle would result

   845 		// in a change to the area of the display used for the video.

   846 		// The video is always displayed in the intersection of the clipping rectangle

   847 		// and the video extent, so check if this has changed.

   848 		parameterChanged = IntersectionAreaChanged(iClientWindows[pos].iClipRect, aWindowClipRect, iClientWindows[pos].iVideoExtent);

   849 

   850 		iClientWindows[pos].iClipRect = aWindowClipRect;

   851 		}

   852 	else

   853 		{

   854 		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetWindowClipRectL - Clip rect parameter has not changed");

   855 		}

   856 

   857     UpdateCropRegionL(aCropRegion, pos, parameterChanged);

   858 

   859     DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetWindowClipRectL ---");

   860 	}

   861 	

   862 void CMediaClientVideoDisplayBody::SetVideoExtentL(const RWindowBase& aWindow, const TRect& aVideoExtent, const TRect& aCropRegion)

   863 	{

   864 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetVideoExtentL +++");

   865     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetVideoExtentL - aWindow WsHandle 0x%X", aWindow.WsHandle());

   866     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetVideoExtentL - aVideoExtent %d,%d - %d,%d", aVideoExtent.iTl.iX, aVideoExtent.iTl.iY, aVideoExtent.iBr.iX, aVideoExtent.iBr.iY);

   867     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetVideoExtentL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   868 

   869     TInt pos = iClientWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

   870 	User::LeaveIfError(pos);

   871 

   872 	TBool parameterChanged = EFalse;

   873 	if (aVideoExtent != iClientWindows[pos].iVideoExtent)

   874 		{

   875 		iClientWindows[pos].iVideoExtent = aVideoExtent;

   876 		parameterChanged = ETrue;

   877 		}

   878 	else

   879 		{

   880 		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetVideoExtentL - Video extent parameter has not changed");

   881 		}

   882 

   883     UpdateCropRegionL(aCropRegion, pos, parameterChanged);

   884     

   885 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetVideoExtentL ---");

   886 	}

   887 	

   888 TBool CMediaClientVideoDisplayBody::HasWindows() const

   889 	{

   890 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::HasWindows +++");

   891 	DEBUG_PRINTF2("CMediaClientVideoDisplayBody::HasWindows --- return %d", (iClientWindows.Count() > 0));

   892 	return (iClientWindows.Count() > 0);

   893 	}

   894 	

   895 TInt CMediaClientVideoDisplayBody::SetBackgroundSurface(TWindowData& aWindowData,  

   896 									const TRect& aCropRegion)

   897 	{

   898 	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SetBackgroundSurface +++");

   899     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetBackgroundSurface - iWindow WsHandle 0x%X", aWindowData.iWindow->WsHandle());

   900     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - iWindow abs pos %d,%d - width %d, height %d", aWindowData.iWindow->AbsPosition().iX, aWindowData.iWindow->AbsPosition().iY, aWindowData.iWindow->Size().iWidth, aWindowData.iWindow->Size().iHeight);

   901     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - iClipRect %d,%d - %d,%d", aWindowData.iClipRect.iTl.iX, aWindowData.iClipRect.iTl.iY, aWindowData.iClipRect.iBr.iX, aWindowData.iClipRect.iBr.iY);

   902     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - iVideoExtent %d,%d - %d,%d", aWindowData.iVideoExtent.iTl.iX, aWindowData.iVideoExtent.iTl.iY, aWindowData.iVideoExtent.iBr.iX, aWindowData.iVideoExtent.iBr.iY);

   903     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SetBackgroundSurface - iScaleWidth %f, iScaleHeight %f", aWindowData.iScaleWidth, aWindowData.iScaleHeight);

   904     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetBackgroundSurface - iRotation %d", aWindowData.iRotation);

   905     DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetBackgroundSurface - iAutoScaleType %d", aWindowData.iAutoScaleType);

   906     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SetBackgroundSurface - iHorizPos %d, iVertPos %d", aWindowData.iHorizPos, aWindowData.iVertPos);

   907     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

   908 	

   909 	// required as this private function is called directly from external friend class

   910 	iCropRegion = aCropRegion;

   911 

   912     // viewport is the viewable area of surface

   913     TRect viewport(iCropRect);

   914     if (aCropRegion.Width() > 0 || aCropRegion.Height() > 0)

   915         {

   916         viewport.Intersection(aCropRegion);

   917         }

   918     

   919     // Viewport is 0 size, don't show any video

   920     if (viewport.Width() <= 0 || viewport.Height() <= 0)

   921         {

   922         DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetBackgroundSurface --- Returned with error %d", KErrArgument);

   923         return KErrArgument;

   924         }

   925 

   926     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - viewport1 %d,%d - %d,%d", viewport.iTl.iX, viewport.iTl.iY, viewport.iBr.iX, viewport.iBr.iY);

   927 

   928     TRect videoExtent(aWindowData.iVideoExtent);

   929 

   930     TReal32 inputWidth = 0.0f;

   931     TReal32 inputHeight = 0.0f;

   932     TReal32 pixelAspectRatio = 0.0f;

   933     switch (aWindowData.iRotation)

   934         {

   935         case EVideoRotationNone:

   936         case EVideoRotationClockwise180:

   937             inputWidth = static_cast<TReal32>(viewport.Width());

   938             inputHeight = static_cast<TReal32>(viewport.Height());

   939             pixelAspectRatio = static_cast<TReal32>(iAspectRatio.iNumerator) / iAspectRatio.iDenominator;

   940             break;

   941         case EVideoRotationClockwise90:

   942         case EVideoRotationClockwise270:

   943             inputWidth = static_cast<TReal32>(viewport.Height());

   944             inputHeight = static_cast<TReal32>(viewport.Width());

   945             pixelAspectRatio = static_cast<TReal32>(iAspectRatio.iDenominator) / iAspectRatio.iNumerator;

   946             break;

   947         default:

   948             // Should never get to default unless there's been some programming error.

   949 			DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetBackgroundSurface --- Returned with error %d", KErrArgument);

   950 			return KErrArgument;

   951         }

   952     

   953     TReal32 viewportAspect = pixelAspectRatio * inputWidth / inputHeight;

   954     TReal32 vidextAspect = static_cast<TReal32>(videoExtent.Width()) / static_cast<TReal32>(videoExtent.Height());

   955     

   956     DEBUG_PRINTF4("CMediaClientVideoDisplayBody::SetBackgroundSurface - inputWidth %f, inputHeight %f, PAR %f", inputWidth, inputHeight, pixelAspectRatio);

   957     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SetBackgroundSurface - viewportAspect %f, vidextAspect %f", viewportAspect, vidextAspect);

   958 

   959     // Set the extent to the display area in the window.  The final height and with is to 

   960     // be changed by deltaHeight and deltaWidth respectively.

   961     TRect extent(videoExtent);

   962 

   963     TInt deltaHeight = 0;

   964     TInt deltaWidth = 0;

   965     

   966     if (aWindowData.iAutoScaleType == EAutoScaleBestFit)

   967         {

   968         if (viewportAspect > vidextAspect)

   969             {

   970             // Shrink height to get the correct aspect ratio

   971             deltaHeight = (TInt) (extent.Width() / viewportAspect - extent.Height());

   972             }

   973         else

   974             {

   975             // Shrink width to get the correct aspect ratio

   976             deltaWidth = (TInt) (extent.Height() * viewportAspect - extent.Width());

   977             }

   978         }

   979     else if (aWindowData.iAutoScaleType == EAutoScaleClip)

   980         {

   981         if (viewportAspect > vidextAspect)

   982             {

   983             // Expand width to get the correct aspect ratio

   984             deltaWidth = (TInt) (extent.Height() * viewportAspect - extent.Width());

   985             }

   986         else

   987             {

   988             // Expand height to get the correct aspect ratio

   989             deltaHeight = (TInt) (extent.Width() / viewportAspect - extent.Height());

   990             }

   991         }

   992     else if (aWindowData.iAutoScaleType == EAutoScaleStretch)

   993         {

   994         if(iSwitchedToExternalDisplay)

   995             {

   996             UpdateDeltaForExtDisplay(viewportAspect, videoExtent, deltaHeight, deltaWidth);

   997             }

   998         }

   999     else if (aWindowData.iAutoScaleType == EAutoScaleNone)

  1000         {

  1001         // for non-square pixels, reduce one dimension

  1002         // XXX other option is to enlarge in the other dimension

  1003         if(pixelAspectRatio > 1)

  1004             {

  1005             inputHeight /= pixelAspectRatio;

  1006             }

  1007         else if(pixelAspectRatio < 1)

  1008             {

  1009             inputWidth *= pixelAspectRatio;

  1010             }

  1011         deltaHeight = (TInt) (inputHeight * aWindowData.iScaleHeight * 0.01 - videoExtent.Height());

  1012         deltaWidth = (TInt) (inputWidth * aWindowData.iScaleWidth * 0.01 - videoExtent.Width());

  1013         }

  1014     

  1015     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SetBackgroundSurface - deltaWidth %d, deltaHeight %d", deltaWidth, deltaHeight);

  1016 

  1017     // Change the width of the extent in the proper directions and propertions.

  1018     switch (aWindowData.iHorizPos)

  1019         {

  1020     case EHorizontalAlignCenter:

  1021         extent.iTl.iX -= deltaWidth / 2;

  1022         extent.iBr.iX += deltaWidth / 2;

  1023         break;

  1024     case EHorizontalAlignLeft:

  1025         extent.iBr.iX += deltaWidth;

  1026         break;

  1027     case EHorizontalAlignRight:

  1028         extent.iTl.iX -= deltaWidth;

  1029         break;

  1030     default:

  1031         TInt width = extent.Width() + deltaWidth;

  1032         extent.iTl.iX += aWindowData.iHorizPos;

  1033         extent.iBr.iX = extent.iTl.iX + width;

  1034         break;

  1035         }

  1036     

  1037     // Change the height of the extent in the proper directions and propertions.

  1038     switch (aWindowData.iVertPos)

  1039         {

  1040     case EVerticalAlignCenter:

  1041         extent.iTl.iY -= deltaHeight / 2;

  1042         extent.iBr.iY += deltaHeight / 2;

  1043         break;

  1044     case EVerticalAlignTop:

  1045         extent.iBr.iY += deltaHeight;

  1046         break;

  1047     case EVerticalAlignBottom:

  1048         extent.iTl.iY -= deltaHeight;

  1049         break;

  1050     default:

  1051         TInt height = extent.Height() + deltaHeight;

  1052         extent.iTl.iY += aWindowData.iVertPos;

  1053         extent.iBr.iY = extent.iTl.iY + height;

  1054         break;

  1055         }

  1056         

  1057     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - extent1 %d,%d - %d,%d", extent.iTl.iX, extent.iTl.iY, extent.iBr.iX, extent.iBr.iY);

  1058 

  1059     // The video should not be displayed outside the intended video extent or clipping rectangle.  

  1060     // The extent already has the correct size and position for displaying the entire viewport.  

  1061     // The viewport is clipped such that the video is not moved/distorted when we take the extent 

  1062     // to be the intersection of itself and the intended video extent.

  1063     

  1064     TRect viewableArea(videoExtent);

  1065     viewableArea.Intersection(aWindowData.iClipRect);

  1066     

  1067     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - viewableArea %d,%d - %d,%d", viewableArea.iTl.iX, viewableArea.iTl.iY, viewableArea.iBr.iX, viewableArea.iBr.iY);

  1068 

  1069     // Number of pixels (in window coordinates) to be clipped on the right, bottom, top and left sides of

  1070     // the video.

  1071     TInt dr = Max(0, extent.iBr.iX - viewableArea.iBr.iX);

  1072     TInt db = Max(0, extent.iBr.iY - viewableArea.iBr.iY);

  1073     TInt dt = Max(0, viewableArea.iTl.iY - extent.iTl.iY);

  1074     TInt dl = Max(0, viewableArea.iTl.iX - extent.iTl.iX);

  1075     

  1076     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - dr %d, db %d, dt %d, dl %d", dr, db, dt, dl);

  1077 

  1078     // Calculate the number of pixels in the video per window pixel in both x and y directions.

  1079     TReal32 wRatio = 0.0f; 

  1080     TReal32 hRatio = 0.0f;

  1081 

  1082     // Make sure we don't divide by 0

  1083     if (extent.Width() != 0)

  1084         {

  1085         wRatio = inputWidth / static_cast<TReal32>(extent.Width());

  1086         }

  1087     

  1088     if (extent.Height() != 0)

  1089         {

  1090         hRatio = inputHeight / static_cast<TReal32>(extent.Height());

  1091         }

  1092     

  1093     DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SetBackgroundSurface - wRatio %f, hRatio %f", wRatio, hRatio);

  1094 

  1095     // Clip the viewport 

  1096     switch (aWindowData.iRotation)

  1097     {

  1098     case EVideoRotationNone:

  1099         viewport.iBr.iX -= (TInt) (wRatio * static_cast<TReal32>(dr));

  1100         viewport.iBr.iY -= (TInt) (hRatio * static_cast<TReal32>(db));

  1101         viewport.iTl.iX += (TInt) (wRatio * static_cast<TReal32>(dl));

  1102         viewport.iTl.iY += (TInt) (hRatio * static_cast<TReal32>(dt));

  1103         break;

  1104     case EVideoRotationClockwise180:

  1105         viewport.iBr.iX -= (TInt) (wRatio * static_cast<TReal32>(dl));

  1106         viewport.iBr.iY -= (TInt) (hRatio * static_cast<TReal32>(dt));

  1107         viewport.iTl.iX += (TInt) (wRatio * static_cast<TReal32>(dr));

  1108         viewport.iTl.iY += (TInt) (hRatio * static_cast<TReal32>(db));

  1109         break;

  1110     case EVideoRotationClockwise90:

  1111         viewport.iBr.iX -= (TInt) (wRatio * static_cast<TReal32>(db));

  1112         viewport.iBr.iY -= (TInt) (hRatio * static_cast<TReal32>(dl));

  1113         viewport.iTl.iX += (TInt) (wRatio * static_cast<TReal32>(dt));

  1114         viewport.iTl.iY += (TInt) (hRatio * static_cast<TReal32>(dr));

  1115         break;

  1116     case EVideoRotationClockwise270:

  1117         viewport.iBr.iX -= (TInt) (wRatio * static_cast<TReal32>(dt));

  1118         viewport.iBr.iY -= (TInt) (hRatio * static_cast<TReal32>(dr));

  1119         viewport.iTl.iX += (TInt) (wRatio * static_cast<TReal32>(db));

  1120         viewport.iTl.iY += (TInt) (hRatio * static_cast<TReal32>(dl));

  1121         break;

  1122     default:

  1123         // Should never get to default unless there's been some programming error.

  1124 		DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SetBackgroundSurface --- Returned with error %d", KErrArgument);

  1125         return KErrArgument;

  1126     }

  1127     

  1128     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - viewport2 %d,%d - %d,%d", viewport.iTl.iX, viewport.iTl.iY, viewport.iBr.iX, viewport.iBr.iY);

  1129 

  1130     // Clip the extent.

  1131     extent.Intersection(viewableArea);

  1132     

  1133     DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SetBackgroundSurface - extent2 %d,%d - %d,%d", extent.iTl.iX, extent.iTl.iY, extent.iBr.iX, extent.iBr.iY);

  1134