diff -r 839377eedc2b -r befca0ec475f videoplayback/videoplaybackviews/src/mpxvideoplaybackdisplayhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videoplayback/videoplaybackviews/src/mpxvideoplaybackdisplayhandler.cpp Wed Sep 01 12:30:28 2010 +0100 @@ -0,0 +1,725 @@ +/* +* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implementation of video playback display handler +* +*/ + + +// Version : %version: 17 % + + +#include +#include +#include +#include +#include +#include + +#include "mpxvideoplaybackdisplayhandler.h" +#include "mpxvideoregion.h" +#include "mpxvideoplaybackviewfiledetails.h" +#include "mpxvideoplaybackcontainer.h" +#include "mpxcommonvideoplaybackview.hrh" + + +_LIT( KAspectRatioFile, "c:\\private\\200159b2\\mpxvideoplayer_aspect_ratio.dat" ); + + +CMPXVideoPlaybackDisplayHandler::CMPXVideoPlaybackDisplayHandler( + MMPXPlaybackUtility* aPlayUtil, + CMPXVideoPlaybackContainer* aContainer) + : iPlaybackUtility( aPlayUtil ) + , iContainer( aContainer ) + , iScaleWidth( 100.0f ) + , iScaleHeight( 100.0f ) + , iHorizontalPosition( EHorizontalAlignCenter ) + , iVerticalPosition( EVerticalAlignCenter ) + , iRotation( EVideoRotationNone ) + , iAutoScale( EAutoScaleBestFit ) +{ +} + +CMPXVideoPlaybackDisplayHandler::~CMPXVideoPlaybackDisplayHandler() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::~CMPXVideoPlaybackDisplayHandler()")); + + MPX_TRAPD( error, SaveAspectRatioL() ); + + iAspectRatioArray.Close(); + + if ( iVideoDisplay ) + { + delete iVideoDisplay; + iVideoDisplay = NULL; + } + + iSurfaceId = TSurfaceId::CreateNullId(); +} + +CMPXVideoPlaybackDisplayHandler* +CMPXVideoPlaybackDisplayHandler::NewL( MMPXPlaybackUtility* aPlayUtil, + CMPXVideoPlaybackContainer* aContainer ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::NewL()")); + + CMPXVideoPlaybackDisplayHandler* self = + new(ELeave) CMPXVideoPlaybackDisplayHandler( aPlayUtil, aContainer ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + return self; +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::ConstructL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::ConstructL() +{ + LoadAspectRatioL(); + + TRect displayRect = iContainer->Rect(); + iDisplayAspectRatio = (TReal32)displayRect.Width() / (TReal32)displayRect.Height(); + + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::ConstructL() iDisplayAspectRatio = %f"), + iDisplayAspectRatio ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::CreateDisplayWindowL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::CreateDisplayWindowL( + CWsScreenDevice& aScreenDevice, + RWindow& aWin, + CMPXVideoPlaybackViewFileDetails* aFileDetails ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::CreateDisplayWindowL()")); + + // + // Save off the video aspect ratio + // + iVideoHeight = aFileDetails->iVideoHeight; + iVideoWidth = aFileDetails->iVideoWidth; + + MPX_DEBUG( + _L("CMPXVideoPlaybackDisplayHandler::CreateDisplayWindowL() clip size (%d,%d)"), + iVideoHeight, iVideoWidth ); + + AddDisplayWindowL( aScreenDevice, aWin, &aWin ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::RemoveDisplayWindow() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::RemoveDisplayWindow() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::RemoveDisplayWindow()")); + + if ( iVideoDisplay ) + { + // + // Surface is being removed, signal the container so it can reset the background + // + if ( iContainer ) + { + MPX_TRAPD( err, iContainer->HandleCommandL( EMPXPbvSurfaceRemoved ) ); + } + + delete iVideoDisplay; + iVideoDisplay = NULL; + } + + iSurfaceId = TSurfaceId::CreateNullId(); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::HandleVideoDisplayMessageL() +// ------------------------------------------------------------------------------------------------- +// +void +CMPXVideoPlaybackDisplayHandler::HandleVideoDisplayMessageL( CMPXMessage* aMessage ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::HandleVideoDisplayMessageL()")); + + TMPXVideoDisplayCommand message = + ( *(aMessage->Value(KMPXMediaVideoDisplayCommand)) ); + + switch ( message ) + { + case EPbMsgVideoSurfaceCreated: + { + SurfaceCreatedL( aMessage ); + break; + } + case EPbMsgVideoSurfaceChanged: + { + SurfaceChangedL( aMessage ); + break; + } + case EPbMsgVideoSurfaceRemoved: + { + SurfaceRemoved(); + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::CalculateAspectRatioL +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::CalculateAspectRatioL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::CalculateAspectRatioL()")); + + if ( iVideoHeight > 0 && iVideoWidth > 0 ) + { + TMMFScalingType scalingType = EMMFNatural; + + TReal videoAspectRatio = CalculateVideoAspectRatio(); + + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::CalculateAspectRatioL() displayAR = %f videoAR = %f)"), + iDisplayAspectRatio, videoAspectRatio ); + + TInt cnt = iAspectRatioArray.Count(); + TInt i = 0; + + // + // check whether dat file has the information about (videoRatio + screenRatio) + // + for ( ; i < cnt ; i++ ) + { + if ( IsAspectRatioEqual( iAspectRatioArray[i].videoRatio, videoAspectRatio ) && + IsAspectRatioEqual( iAspectRatioArray[i].screenRatio, iDisplayAspectRatio ) && + ( scalingType = iAspectRatioArray[i].scalingType ) > 0 ) + { + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::CalculateAspectRatioL() ratio found)")); + break; + } + } + + // + // if can't find out match aspect ratio in dat file, + // choose the scaling type through the rule + // aspectRatioDiff = videoAspectRatio - aDisplayAspectRatio + // aspectRatioDiff == 0 ==> natural + // aspectRatioDiff > 0.1 ==> zoom + // aspectRatioDiff < - 0.3 ==> natural + // aspectRatioDiff >= - 0.3 and <= 0.1 ==> stretch + // + if ( i == cnt ) + { + if ( videoAspectRatio - iDisplayAspectRatio > 0.1 ) + { + scalingType = EMMFZoom; + } + else if ( ( ! IsAspectRatioEqual( videoAspectRatio, iDisplayAspectRatio ) ) && + ( videoAspectRatio - iDisplayAspectRatio > (- 0.3) ) ) + { + scalingType = EMMFStretch; + } + + TMPXAspectRatio ratio; + + ratio.videoRatio = videoAspectRatio; + ratio.screenRatio = iDisplayAspectRatio; + ratio.scalingType = scalingType; + + iAspectRatioArray.Append( ratio ); + } + + iCurrentIndexForAspectRatio = i; + + TMPXVideoPlaybackCommand aspectRatioCmd = EPbCmdNaturalAspectRatio; + + if ( scalingType == EMMFZoom ) + { + aspectRatioCmd = EPbCmdZoomAspectRatio; + } + else if ( scalingType == EMMFStretch ) + { + aspectRatioCmd = EPbCmdStretchAspectRatio; + } + + SetAspectRatioL( aspectRatioCmd ); + + // + // If the screen aspect ratio and the video aspect ratio are not equal, + // signal the controls controller to create the aspect ratio icon + // + if ( ShowAspectRatioIcon() ) + { + iContainer->HandleEventL( EMPXControlCmdCreateAspectRatioIcon ); + } + else + { + iContainer->HandleEventL( EMPXControlCmdDeleteAspectRatioIcon ); + } + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::SaveAspectRatioL +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::SaveAspectRatioL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::SaveAspectRatioL")); + + RFs fs; + TInt err = fs.Connect(); + CleanupClosePushL( fs ); + + TBool canSave = EFalse; + + TRAP_IGNORE( canSave = ! SysUtil::FFSSpaceBelowCriticalLevelL( + &fs, sizeof(TMPXAspectRatio) * iAspectRatioArray.Count()) ); + + if ( canSave ) + { + // save list to disk + RFileWriteStream out; + + TInt err( out.Replace( fs, KAspectRatioFile, EFileWrite ) ); + + if ( err == KErrPathNotFound ) + { + fs.MkDirAll( KAspectRatioFile ); + err = out.Create( fs, KAspectRatioFile, EFileWrite ); + } + + if ( ! err ) + { + TInt cnt = iAspectRatioArray.Count(); + + MPX_TRAP( err, + { + for ( TInt i = 0 ; i < cnt ; i++ ) + { + // + // Save (videoRatio + screenRatio + scalingType) + // + out.WriteReal32L( iAspectRatioArray[i].videoRatio ); + out.WriteReal32L( iAspectRatioArray[i].screenRatio ); + out.WriteInt8L( iAspectRatioArray[i].scalingType ); + } + } ); + + out.Close(); + } + } + + CleanupStack::PopAndDestroy(); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::LoadAspectRatioL +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::LoadAspectRatioL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::LoadAspectRatioL()")); + + RFs fs; + RFileReadStream in; + + TInt err = fs.Connect(); + CleanupClosePushL( fs ); + + if ( ! err && in.Open( fs, KAspectRatioFile, EFileRead ) == KErrNone ) + { + TMPXAspectRatio ratio; + + MPX_TRAP( err, + { + for ( err = KErrNone ; err == KErrNone ; ) + { + // + // Read (videoRatio + screenRatio + scalingType) + // + ratio.videoRatio = in.ReadReal32L(); + ratio.screenRatio = in.ReadReal32L(); + ratio.scalingType = (TMMFScalingType)in.ReadInt8L(); + + iAspectRatioArray.Append( ratio ); + } + } ); + + in.Close(); + } + + CleanupStack::PopAndDestroy(); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::AddDisplayWindowL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::AddDisplayWindowL( CWsScreenDevice& aScreenDevice, + RWindowBase& aWindowBase, + RWindow* aWin ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::AddDisplayWindowL()")); + + TInt displayId = aScreenDevice.GetScreenNumber(); + + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::AddDisplayWindowL() displayId %d"), displayId); + + CMediaClientVideoDisplay* tempDisplay = iVideoDisplay; + + iVideoDisplay = CMediaClientVideoDisplay::NewL( displayId ); + + delete tempDisplay; + + TRect cropRect = TRect( aWin->Size() ); + + MPX_DEBUG( + _L("CMPXVideoPlaybackDisplayHandler::AddDisplayWindowL() cropRect (%d, %d), (%d, %d)"), + cropRect.iTl.iX, cropRect.iTl.iY, cropRect.iBr.iX, cropRect.iBr.iY); + + MPX_TRAPD( dispError, + iVideoDisplay->AddDisplayWindowL( &aWindowBase, + cropRect, + cropRect, + cropRect, + iScaleWidth, + iScaleHeight, + iRotation, + iAutoScale, + iHorizontalPosition, + iVerticalPosition, + aWin ); + ); + + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::AddDisplayWindowL() Display Added")); + + // + // Check if surface was created before window was ready + // + if ( iSurfaceCached && ! iContainer->IsRealOneBitmapTimerActive() ) + { + AttachNewSurfaceToWindowL(); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::SurfaceCreatedL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::SurfaceCreatedL( CMPXMessage* aMessage ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::SurfaceCreatedL()")); + + TSurfaceId oldSurfaceId = iSurfaceId; + + // + // Extract the surface parameters from the message + // + iSurfaceId = aMessage->ValueTObjectL( KMPXMediaVideoDisplayTSurfaceId ); + iCropRect = aMessage->ValueTObjectL( KMPXMediaVideoDisplayCropRect ); + iAspectRatio = aMessage->ValueTObjectL( KMPXMediaVideoDisplayAspectRatio ); + + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::SurfaceCreatedL iCropRect[(%d,%d),(%d,%d)] iAspectRatio = (%d,%d)"), + iCropRect.iTl.iX, iCropRect.iTl.iY, iCropRect.iBr.iX, iCropRect.iBr.iY, + iAspectRatio.iNumerator, iAspectRatio.iDenominator ); + + // + // Add the surface unless the video display hasn't been created or + // the Real One bitmap is being shown. + // + if ( iVideoDisplay && ! iContainer->IsRealOneBitmapTimerActive() ) + { + // + // Remove old surface if one exists + // + if ( ! oldSurfaceId.IsNull() ) + { + iVideoDisplay->RemoveSurface(); + } + + AttachNewSurfaceToWindowL(); + } + else + { + // + // Save the surface information to add it when the display is ready + // + iSurfaceCached = ETrue; + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::SurfaceChangedL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::SurfaceChangedL( CMPXMessage* aMessage ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::SurfaceChangedL()")); + + TVideoAspectRatio oldAspectRatio = iAspectRatio; + + // + // Extract the surface parameters from the message + // + iSurfaceId = aMessage->ValueTObjectL( KMPXMediaVideoDisplayTSurfaceId ); + iCropRect = aMessage->ValueTObjectL( KMPXMediaVideoDisplayCropRect ); + iAspectRatio = aMessage->ValueTObjectL( KMPXMediaVideoDisplayAspectRatio ); + + // + // Check if the surface has been cached + // If surface has been cached, exit since the surface parameters have been saved + // + if ( ! iSurfaceCached && iVideoDisplay ) + { + // + // Add new surface + // + iVideoDisplay->SurfaceParametersChanged( iSurfaceId, iCropRect, iAspectRatio ); + iVideoDisplay->RedrawWindows( iCropRect ); + + // + // Update the Aspect Ratio if it changed on the surface + // + if ( oldAspectRatio != iAspectRatio ) + { + CalculateAspectRatioL(); + } + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::RemoveSurfaceFromPlaybackPluginL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::RemoveSurfaceFromPlaybackPluginL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::RemoveSurfaceFromPlaybackPluginL()")); + + CMPXCommand* cmd = CMPXCommand::NewL(); + CleanupStack::PushL( cmd ); + + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback ); + cmd->SetTObjectValueL( KMPXMediaVideoPlaybackCommand, + EPbCmdSurfaceRemovedFromWindow ); + cmd->SetTObjectValueL( KMPXMediaVideoDisplayTSurfaceId, iSurfaceId ); + + iPlaybackUtility->CommandL( *cmd ); + CleanupStack::PopAndDestroy( cmd ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::SurfaceRemoved() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::SurfaceRemoved() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::SurfaceRemoved()")); + + if ( iVideoDisplay ) + { + if ( iContainer ) + { + MPX_TRAPD( err, iContainer->HandleCommandL( EMPXPbvSurfaceRemoved ) ); + } + + iVideoDisplay->RemoveSurface(); + + // + // Signal the playback plugin to remove the surface from Helix + // + MPX_TRAPD( err2, RemoveSurfaceFromPlaybackPluginL() ); + } + + iSurfaceId = TSurfaceId::CreateNullId(); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::SetAspectRatioL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::SetAspectRatioL( TMPXVideoPlaybackCommand aCmd ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::SetAspectRatioL()"), + _L("aCmd = %d"), aCmd); + + TInt aspectRatio = EMMFNatural; + + switch ( aCmd ) + { + case EPbCmdNaturalAspectRatio: + { + iAutoScale = EAutoScaleBestFit; + aspectRatio = EMMFNatural; + break; + } + case EPbCmdZoomAspectRatio: + { + iAutoScale = EAutoScaleClip; + aspectRatio = EMMFZoom; + break; + } + case EPbCmdStretchAspectRatio: + { + iAutoScale = EAutoScaleStretch; + aspectRatio = EMMFStretch; + break; + } + } + + if ( iVideoDisplay && ! iSurfaceId.IsNull() ) + { + iVideoDisplay->SetAutoScaleL( iAutoScale, + iHorizontalPosition, + iVerticalPosition, + iCropRect ); + } + + // + // Update the controls controller with the new aspect ratio + // + if ( iContainer ) + { + iContainer->HandleEventL( EMPXControlCmdSetAspectRatio, aspectRatio ); + } + + // + // Update the aspect ratio in the array + // + TInt count = iAspectRatioArray.Count(); + + if ( count > 0 && count > iCurrentIndexForAspectRatio ) + { + iAspectRatioArray[iCurrentIndexForAspectRatio].scalingType = (TMMFScalingType)aspectRatio; + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::DoHandleRealOneBitmapTimeoutL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::DoHandleRealOneBitmapTimeoutL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::DoHandleRealOneBitmapTimeoutL()")); + + // + // Check if surface was created before window was ready + // + if ( iSurfaceCached && iVideoDisplay ) + { + AttachNewSurfaceToWindowL(); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::AttachNewSurfaceToWindowL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackDisplayHandler::AttachNewSurfaceToWindowL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackDisplayHandler::AttachNewSurfaceToWindowL()")); + + // + // Calculate the video aspect ratio and set the proper value on the video display + // before attaching the surface + // + CalculateAspectRatioL(); + + iVideoDisplay->SurfaceCreated( iSurfaceId, iCropRect, iAspectRatio, iCropRect ); + + if ( iContainer ) + { + iContainer->HandleCommandL( EMPXPbvSurfaceCreated ); + } + + iSurfaceCached = EFalse; +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::ShowAspectRatioIcon() +// ------------------------------------------------------------------------------------------------- +// +TBool CMPXVideoPlaybackDisplayHandler::ShowAspectRatioIcon() +{ + TBool showAspectRatio = ETrue; + + TReal videoAspectRatio = CalculateVideoAspectRatio(); + + if ( IsAspectRatioEqual( videoAspectRatio, iDisplayAspectRatio ) ) + { + showAspectRatio = EFalse; + } + + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::ShowAspectRatioIcon(%d)"), showAspectRatio); + + return showAspectRatio; +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::IsAspectRatioEqual() +// ------------------------------------------------------------------------------------------------- +// +TBool CMPXVideoPlaybackDisplayHandler::IsAspectRatioEqual( TReal aRatio1, TReal aRatio2 ) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::IsAspectRatioEqual() ar1 = %f ar2 = %f)"), + aRatio1, aRatio2 ); + + TBool valuesEqual = EFalse; + TReal arDiff = aRatio1 - aRatio2; + + if ( arDiff < 0.00001 && arDiff > -0.00001 ) + { + valuesEqual = ETrue; + } + + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::IsAspectRatioEqual(%d)"), valuesEqual); + + return valuesEqual; +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackDisplayHandler::CalculateVideoAspectRatio() +// ------------------------------------------------------------------------------------------------- +// +TReal CMPXVideoPlaybackDisplayHandler::CalculateVideoAspectRatio() +{ + TReal videoAspectRatio = 0.0; + + if ( iVideoHeight > 0 && iVideoWidth > 0 ) + { + videoAspectRatio = (TReal32)iVideoWidth / (TReal32)iVideoHeight; + + // + // If the pixel aspect ratio is valid, use it to modify the videoAspectRatio + // + if ( iAspectRatio.iDenominator ) + { + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::CalculateVideoAspectRatio() iAspectRatio = (%d,%d)"), + iAspectRatio.iNumerator, iAspectRatio.iDenominator ); + + TReal32 par = (TReal32)iAspectRatio.iNumerator / (TReal32)iAspectRatio.iDenominator; + + videoAspectRatio *= par; + } + } + + MPX_DEBUG(_L("CMPXVideoPlaybackDisplayHandler::CalculateVideoAspectRatio(%f)"), videoAspectRatio ); + + return videoAspectRatio; +} + +// End of File