diff -r 000000000000 -r 5f000ab63145 phoneuis/BubbleManager/Src/BMVideoPlayer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phoneuis/BubbleManager/Src/BMVideoPlayer.cpp Mon Jan 18 20:18:27 2010 +0200 @@ -0,0 +1,937 @@ +/* +* Copyright (c) 2007 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: Video player implementation. +* +*/ + + +// INCLUDE FILES +#include // CCoeEnv +#include // CEikEnv +#include // CVideoPlayerUtility +#include "BMVideoPlayer.h" +#include "BMVideoPlayerObserver.h" +#include "BMPanic.h" +#include "BMTrace.h" + +// EXTERNAL DATA STRUCTURES + +// EXTERNAL FUNCTION PROTOTYPES + +// CONSTANTS +const TInt KBubbleVideoMinVolumeLevel = 0; +const TInt KBubbleVideoMaxVolumeLevel = 10; +const TInt KBubbleVideoVolumeRampInterval = 3000000; +const TInt KBubbleVideoVolumeRampStep = 1; +const TInt KBubbleVideoRepeatsTrailPause = 1000000; +const TInt KBubbleVideoIACoef = 1000; // Precision for fixed point math +const TInt KBubbleMaxVideoCrop = 0; // Allowed max cropping. 0, 1 .. 20 (%). +// The margin between aWindowRect and aClipRect parameters passed to player, +// which can be used to eliminate black fill (scaled image is matched to +// target area by clipping it). +const TInt KBubbleVideoClipMarginX = 2; +const TInt KBubbleVideoClipMarginY = 2; + + +// MACROS + +// LOCAL CONSTANTS AND MACROS + +// MODULE DATA STRUCTURES + +// LOCAL FUNCTION PROTOTYPES +TInt DivideAndCeil(const TInt aVal, const TInt aDiv) + { + return (((aVal%aDiv)>0) ? (TInt)((aVal/aDiv)+1):(TInt)(aVal/aDiv)); + } + +// --------------------------------------------------------------------------- +// C++ constructor +// --------------------------------------------------------------------------- +// +CBubbleVideoPlayer::CBubbleVideoPlayer( + MBubbleVideoPlayerObserver& aObserver ) + : + iObserver( aObserver ), + iVideoPlayer( NULL ), + iPlayerState( EVideoClosed ), + iVolume( 0 ) + { + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::ConstructL +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::ConstructL( + const TDesC& aFileName, + TInt aPriority, + TUint aPreference, + RWindow& aVideoTarget ) + { + BUBBLE_PRINT("VideoPlayer::Const>"); + // Screen and clip rectangles to window dimensions + TPoint wndPosition( aVideoTarget.AbsPosition() ); + TSize wndSize( aVideoTarget.Size() ); + TRect wndRect( wndPosition, wndSize ); + + // Create video player instance + CCoeEnv* coeEnv = CCoeEnv::Static(); + iVideoPlayer = CVideoPlayerUtility::NewL( + *this, + aPriority, + static_cast( aPreference ), + coeEnv->WsSession(), + *coeEnv->ScreenDevice(), + aVideoTarget, + wndRect, + wndRect ); + + RFs fs = CEikonEnv::Static()->FsSession(); + User::LeaveIfError( iFileHandle.Open( fs, + aFileName, + EFileShareReadersOnly | + EFileStream | + EFileRead ) ); + + iVideoPlayer->OpenFileL( iFileHandle ); // async + + iPlayerState = EVideoOpening; + BUBBLE_PRINT("VideoPlayer::Const<"); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::NewL +// ----------------------------------------------------------------------------- +// +CBubbleVideoPlayer* CBubbleVideoPlayer::NewL( + const TDesC& aRingingTone, + TInt aPriority, + TUint aPreference, + MBubbleVideoPlayerObserver& aObserver, + RWindow& aVideoTarget ) + { + CBubbleVideoPlayer* self = new(ELeave) CBubbleVideoPlayer( aObserver ); + + CleanupStack::PushL( self ); + self->ConstructL( aRingingTone, + aPriority, aPreference, + aVideoTarget ); + CleanupStack::Pop(); + + return self; + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::New +// ----------------------------------------------------------------------------- +// +CBubbleVideoPlayer* CBubbleVideoPlayer::New( + const TDesC& aRingingTone, + TInt aPriority, + TUint aPreference, + MBubbleVideoPlayerObserver& aObserver, + RWindow& aVideoTarget ) + { + CBubbleVideoPlayer* self = NULL; + + TRAPD( ignore, self = CBubbleVideoPlayer::NewL( + aRingingTone, + aPriority, + aPreference, + aObserver, + aVideoTarget ) ); + ignore = ignore; + + return self; // this is NULL if NewL leaves + } + +// ----------------------------------------------------------------------------- +// Destructor +// ----------------------------------------------------------------------------- +// +CBubbleVideoPlayer::~CBubbleVideoPlayer() + { + if ( iVolumeRampTimer ) + { + iVolumeRampTimer->Cancel(); + delete iVolumeRampTimer; + } + + if ( iRepeatsTrailPauseTimer ) + { + iRepeatsTrailPauseTimer->Cancel(); + delete iRepeatsTrailPauseTimer; + } + + if ( iVideoPlayer ) + { + iVideoPlayer->Close(); + delete iVideoPlayer; + } + + iFileHandle.Close(); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::Play +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::Play( TRingingType aRingType, + TInt aVolume ) + { + BUBBLE_PRINT("VideoPlayer::Play>"); + __ASSERT_DEBUG( iVideoPlayer, Panic( EBMPanicVideoPlayer ) ); + + iRingingType = aRingType; + iVolume = aVolume; + + switch( iPlayerState ) + { + case EVideoOpening: + case EVideoPreparing: + case EVideoOpen: + // see MvpuoPrepareComplete() + iToBePlayed = ETrue; + break; + + case EVideoReady: + case EVideoPaused: + iVideoPlayer->Play(); + iPlayerState = EVideoPlaying; + break; + + case EVideoPlaying: + case EVideoClosed: + case EVideoError: + default: + // NOP + break; + } + + BUBBLE_PRINT("VideoPlayer::Play<"); + return; + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::StopPlaying +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::StopPlaying() + { + BUBBLE_PRINT("VideoPlayer::Stop>"); + iToBePlayed = EFalse; + + if ( iVolumeRampTimer ) + { + iVolumeRampTimer->Cancel(); + } + + if ( iRepeatsTrailPauseTimer ) + { + iRepeatsTrailPauseTimer->Cancel(); + } + + if ( iPlayerState == EVideoPlaying || + iPlayerState == EVideoPaused ) + { + iVideoPlayer->Stop(); + iPlayerState = EVideoReady; + } + BUBBLE_PRINT("VideoPlayer::Stop<"); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::PausePlaying +// ----------------------------------------------------------------------------- +// +TInt CBubbleVideoPlayer::PausePlaying() + { + BUBBLE_PRINT("VideoPlayer::Pause>"); + TInt err = KErrNone; + + if ( iPlayerState == EVideoPlaying ) + { + TRAP( err, iVideoPlayer->PauseL() ); + if ( err == KErrNone ) + { + iPlayerState = EVideoPaused; + } + } + else + { + err = KErrNotReady; + } + + BUBBLE_PRINTF("VideoPlayer::Pause<:", err); + return err; + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::ResumePlaying +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::ResumePlaying() + { + BUBBLE_PRINT("VideoPlayer::Resume>"); + if ( iPlayerState == EVideoPaused ) + { + iVideoPlayer->Play(); + iPlayerState = EVideoPlaying; + } + BUBBLE_PRINT("VideoPlayer::Resume<"); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::MuteAudio +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::MuteAudio() + { + BUBBLE_PRINT("VideoPlayer::Mute"); + if ( iVolumeRampTimer ) + { + iVolumeRampTimer->Cancel(); + } + + iVolume = 0; + SetVolume( 0 ); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::SetVolume +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::SetVolume( TInt aVolume ) + { + BUBBLE_PRINT("VideoPlayer::SetVol>"); + TInt maxVolume( iVideoPlayer->MaxVolume() ); + maxVolume = ( maxVolume > 0 ) ? maxVolume : KBubbleVideoMaxVolumeLevel; + + TInt scaledVolume = ( aVolume * maxVolume ) / KBubbleVideoMaxVolumeLevel; + + TRAP_IGNORE( iVideoPlayer->SetVolumeL( scaledVolume ) ); + BUBBLE_PRINT("VideoPlayer::SetVol<"); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::SetRingingType +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::SetRingingType( TRingingType aRingingType ) + { + BUBBLE_PRINT("VideoPlayer::SetRingType"); + if ( aRingingType == ETypeAscending ) + { + if ( !iVolumeRampTimer ) + { + iVolumeRampTimer = CPeriodic::New( CActive::EPriorityStandard ); + } + + if ( iVolumeRampTimer && !iVolumeRampTimer->IsActive() ) + { + TCallBack cb( VolumeRampTimerCallback, this ); + + SetVolume( KBubbleVideoMinVolumeLevel ); + iRampedVolume = KBubbleVideoMinVolumeLevel; + iVolumeRampTimer->Start( KBubbleVideoVolumeRampInterval, + KBubbleVideoVolumeRampInterval, + cb ); + } + } + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::VolumeRampTimerCallback +// ----------------------------------------------------------------------------- +// +TInt CBubbleVideoPlayer::VolumeRampTimerCallback( TAny* aObj ) + { + return static_cast( aObj )->DoVolumeRamp(); + } + + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::DoVolumeRamp +// ----------------------------------------------------------------------------- +// +TInt CBubbleVideoPlayer::DoVolumeRamp() + { + BUBBLE_PRINT("VideoPlayer::DoVolRamp"); + if ( iRampedVolume < iVolume ) + { + iRampedVolume = iRampedVolume + KBubbleVideoVolumeRampStep; + if ( iRampedVolume >= iVolume ) + { + // target volume level reached + iRampedVolume = iVolume; + iVolumeRampTimer->Cancel(); + } + + SetVolume( iRampedVolume ); + } + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::RepeatsTrailPauseTimerCallback +// ----------------------------------------------------------------------------- +// +TInt CBubbleVideoPlayer::RepeatsTrailPauseTimerCallback( TAny* aObj ) + { + return static_cast( aObj )->DoRingingRepeat(); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::DoRingingRepeat +// ----------------------------------------------------------------------------- +// +TInt CBubbleVideoPlayer::DoRingingRepeat() + { + iRepeatsTrailPauseTimer->Cancel(); + + if ( iPlayerState == EVideoReady ) + { + iVideoPlayer->Play(); + iPlayerState = EVideoPlaying; + } + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::State +// ----------------------------------------------------------------------------- +// +CBubbleVideoPlayer::TVideoPlayerState CBubbleVideoPlayer::State() const + { + return iPlayerState; + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::VideoResolution +// ----------------------------------------------------------------------------- +// +CBubbleVideoPlayer::TVideoResolution CBubbleVideoPlayer::VideoResolution() const + { + TSize frameSize( VideoFrameSize() ); + + // SubQCCIF video resolution is 128x96 pixels + if ( frameSize.iWidth == 128 && frameSize.iHeight == 96 ) + { + return EVideoSubQCIF; + } + else if ( frameSize.iWidth == 176 && frameSize.iHeight == 144 ) + { + return EVideoQCIF; + } + else + { + return EVideoOther; + } + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::VideoResolution +// ----------------------------------------------------------------------------- +// +TSize CBubbleVideoPlayer::VideoFrameSize() const + { + TSize frameSize( 0,0 ); + + TRAPD( err, iVideoPlayer->VideoFrameSizeL( frameSize ) ); + + if ( err != KErrNone ) + { + return TSize(0,0); + } + + return frameSize; + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::AdjustToWindow +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::AdjustToWindow( RWindow& aDisplayWindow, + const TRect& aUncropPane, + TBool aArbitaryScalingSupported ) + { + BUBBLE_PRINT("VideoPlayer::AdjToWin>"); + __ASSERT_DEBUG( ( iPlayerState == EVideoReady || + iPlayerState == EVideoPaused ), + Panic( EBMPanicVideoPlayer ) ); + + // Get video frame dimensions + TSize frameSize( VideoFrameSize() ); + if ( frameSize.iWidth == 0 || frameSize.iHeight == 0 ) + { + return; // invalid + } + + // Get window position and dimensions. + TSize wndSize( aDisplayWindow.Size() ); + TPoint wndPosition( aDisplayWindow.AbsPosition() ); + + // Set screenRect equal to aDisplayWindow. + TRect screenRect( wndPosition, wndSize ); + + TVideoResolution resolution = VideoResolution(); + if ( resolution == EVideoQCIF || resolution == EVideoSubQCIF ) + { + // aUncropPane is valid only for qcif and sqcif. + + // The pane where uncropped video is positioned. + TSize uncropPaneSize( aUncropPane.Size() ); + + // Calculate size for aScreenRect passed to video player. Size is + // calculated so that auto scaled video frame covers uncrop pane. + TSize screenRectSize = CalculateScreenRectSize( + uncropPaneSize, frameSize, aArbitaryScalingSupported ); + + // Position aScreenRect. + screenRect = TRect( aUncropPane.iTl, screenRectSize ); + TInt offsetX = (uncropPaneSize.iWidth - screenRectSize.iWidth) / 2; + TInt offsetY = (uncropPaneSize.iHeight - screenRectSize.iHeight) / 2; + screenRect.Move( offsetX, offsetY ); + } + + // Video is autoscaled by video player. + // iVideoPlayer->SetScaleFactorL(...); + + // Clip to display window + TRect clipRect( wndPosition, wndSize ); + + // Update settings to video player. + CCoeEnv* coeEnv = CCoeEnv::Static(); + TRAP_IGNORE( iVideoPlayer->SetDisplayWindowL( + coeEnv->WsSession(), + *coeEnv->ScreenDevice(), + aDisplayWindow, + screenRect, + clipRect ) ); + BUBBLE_PRINT("VideoPlayer::AdjToWin<"); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::AdjustToWindow2 +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::AdjustToWindow2( + RWindow& aDisplayWindow ) + { + BUBBLE_PRINT("VideoPlayer::AdjToWin2>"); + __ASSERT_DEBUG( ( iPlayerState == EVideoReady || + iPlayerState == EVideoPaused ), + Panic( EBMPanicVideoPlayer ) ); + + // Get video frame dimensions + TSize frameSize( VideoFrameSize() ); + if ( frameSize.iWidth == 0 || frameSize.iHeight == 0 ) + { + return; // invalid + } + + // Get video container position and dimensions + TSize wndSize( aDisplayWindow.Size() ); + TPoint wndPosition( aDisplayWindow.AbsPosition() ); + + // Get sizes for clip and screen rectangles. + TSize clipSize; + TSize screenSize; + CalculateClipAndScreenRectSize( wndSize, + frameSize, + clipSize, + screenSize ); + + // Center clip rectangle to aDisplayWindow + TRect clipRect( wndPosition, clipSize ); + TInt offsetX = (wndSize.iWidth - clipSize.iWidth) / 2; + TInt offsetY = (wndSize.iHeight - clipSize.iHeight) / 2; + clipRect.Move( offsetX, offsetY ); + + // Center screen rectangle to aDisplayWindow + TRect screenRect( wndPosition, screenSize ); + offsetX = (wndSize.iWidth - screenSize.iWidth) / 2; + offsetY = (wndSize.iHeight - screenSize.iHeight) / 2; + screenRect.Move( offsetX, offsetY ); + + iObserver.HandleVideoPlayerBlittingAreaDefined( clipRect ); + + // Update rectangles to video player. + CCoeEnv* coeEnv = CCoeEnv::Static(); + TRAP_IGNORE( iVideoPlayer->SetDisplayWindowL( + coeEnv->WsSession(), + *coeEnv->ScreenDevice(), + aDisplayWindow, + screenRect, + clipRect ) ); + BUBBLE_PRINT("VideoPlayer::AdjToWin2<"); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::CalculateScreenRectSize +// ----------------------------------------------------------------------------- +// +TSize CBubbleVideoPlayer::CalculateScreenRectSize( + const TSize& aCanvasSize, + const TSize& aVideoFrameSize, + TBool aArbitraryScalingSupported ) + { + // Mismatch between canvas size and video size + TInt xDelta( aCanvasSize.iWidth - aVideoFrameSize.iWidth ); + TInt yDelta( aCanvasSize.iHeight - aVideoFrameSize.iHeight ); + + // Find minimum scaling factor to cover canvas by video. + TInt dScaleFactor( KBubbleVideoIACoef ); // use integer arithmetic + + if ( xDelta == 0 && yDelta == 0 ) + { + // correct size, scaling not needed + } + else if ( xDelta < 0 && yDelta == 0 ) + { + // wide, but cannot downscale -> just crop + } + else if ( yDelta < 0 && xDelta == 0 ) + { + // tall, but cannot downscale -> just crop + } + else if ( xDelta > 0 && yDelta > 0 ) + { + // small, narrow and flat -> enlarge + TInt xProp( ( KBubbleVideoIACoef * aCanvasSize.iWidth ) / + aVideoFrameSize.iWidth ); + TInt yProp( ( KBubbleVideoIACoef * aCanvasSize.iHeight ) / + aVideoFrameSize.iHeight ); + + dScaleFactor = xProp > yProp ? xProp : yProp; + } + else if ( xDelta < 0 && yDelta < 0 ) + { + // large, wide and tall -> downscale + TInt xProp( ( KBubbleVideoIACoef * aCanvasSize.iWidth ) / + aVideoFrameSize.iWidth ); + TInt yProp( ( KBubbleVideoIACoef * aCanvasSize.iHeight ) / + aVideoFrameSize.iHeight ); + + dScaleFactor = xProp > yProp ? xProp : yProp; + } + else if ( xDelta > 0 && yDelta <= 0 ) + { + // narrow -> enlarge + dScaleFactor = ( KBubbleVideoIACoef * aCanvasSize.iWidth ) / + aVideoFrameSize.iWidth; + } + else if ( yDelta > 0 && xDelta <= 0 ) + { + // flat -> enlarge + dScaleFactor = ( KBubbleVideoIACoef * aCanvasSize.iHeight) / + aVideoFrameSize.iHeight; + } + else + { + // do nothing + } + + if ( !aArbitraryScalingSupported ) + { + TInt remainder( dScaleFactor % KBubbleVideoIACoef ); + + /////////////////////////////////////////////////////// + // Fixed scales are 200, 162, 137, 112, 100, 50 ( %) + // Fixed values not used: 325, 275, 250, 225, + /////////////////////////////////////////////////////// + if ( dScaleFactor > ( 2 * KBubbleVideoIACoef ) ) + { + dScaleFactor = ( 2 * KBubbleVideoIACoef ); // 200% is MAX + } + else if ( remainder ) + { + if ( dScaleFactor > KBubbleVideoIACoef ) + { + // upscale + TInt scale = ( 100 * dScaleFactor ) / KBubbleVideoIACoef; + + if ( scale > 162 ) + { + // 200% + dScaleFactor = 2 * KBubbleVideoIACoef; + } + else if ( scale > 137 ) + { + // 162% + dScaleFactor = 162 * ( KBubbleVideoIACoef / 100 ); + } + else if ( scale > 112 ) + { + // 137% + dScaleFactor = 137 * ( KBubbleVideoIACoef / 100 ); + } + else + { + // 112% + dScaleFactor = 112 * ( KBubbleVideoIACoef / 100 ); + } + } + else + { + // downscale + if ( remainder > ( KBubbleVideoIACoef / 2 ) ) + { + dScaleFactor = KBubbleVideoIACoef; // 100% + } + else + { + dScaleFactor = ( KBubbleVideoIACoef / 2 ); // 50% + } + } + } + } + + //////////////////////////////////////////////// + // Calculate scaled frame size (virtual canvas) + //////////////////////////////////////////////// + TInt screenWidth = DivideAndCeil( + ( dScaleFactor * aVideoFrameSize.iWidth ), + KBubbleVideoIACoef ); + TInt screenHeight = DivideAndCeil( + ( dScaleFactor * aVideoFrameSize.iHeight ), + KBubbleVideoIACoef ); + + return TSize( screenWidth, screenHeight ); + } + +// ----------------------------------------------------------------------------- +// CBubbleVideoPlayer::CalculateClipAndScreenRectSize +// ----------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::CalculateClipAndScreenRectSize( + const TSize& aWindowSize, + const TSize& aVideoFrameSize, + TSize& aClipSize, + TSize& aScreenSize ) + { + // Check aspect ratios + // aWindowSize or aVideoFrameSize cannot be zero in this phase. + TInt windowAspectRatio = ( KBubbleVideoIACoef * aWindowSize.iWidth ) / + aWindowSize.iHeight; + TInt videoAspectRatio = ( KBubbleVideoIACoef * aVideoFrameSize.iWidth ) / + aVideoFrameSize.iHeight; + + + if ( videoAspectRatio == windowAspectRatio ) + { + // Aspect ratios are same. + + // Set clip and screen rect equal to window. + // Scaled video will cover window entirely. + aClipSize = aWindowSize; + aScreenSize = aWindowSize; + } + else if ( windowAspectRatio > videoAspectRatio ) + { + // Window is more wide screen than video. + + // Window height sets the limit. + TInt maxHeight = aWindowSize.iHeight; + + // Calculate max scale according to allowed crop. + // Formula: + // ( 100 - crop ) visible window_height x scale x video_width + // -------------- = ------- = ----------------------------------- + // 100 scaled_size (scale)^2 x video_width x video_height + // + TInt dScaleFactor = ( maxHeight * 100 * KBubbleVideoIACoef ) / + ( (100 - KBubbleMaxVideoCrop) * aVideoFrameSize.iHeight ); + + TInt scaledWidth = + DivideAndCeil( ( dScaleFactor * aVideoFrameSize.iWidth ), + KBubbleVideoIACoef ); + + // Limit to window width + if ( scaledWidth > aWindowSize.iWidth ) + { + scaledWidth = aWindowSize.iWidth; + dScaleFactor = ( KBubbleVideoIACoef * aWindowSize.iWidth ) / + aVideoFrameSize.iWidth; + } + + TInt scaledHeight = + DivideAndCeil( ( dScaleFactor * aVideoFrameSize.iHeight ), + KBubbleVideoIACoef ); + + aClipSize = TSize( scaledWidth, maxHeight ); + aScreenSize = TSize( scaledWidth + ( 2 * KBubbleVideoClipMarginX ), + scaledHeight + ( 2 * KBubbleVideoClipMarginY ) ); + } + else + { + // Video is more wide screen than window. + + // Window width sets the limit. + TInt maxWidth = aWindowSize.iWidth; + + // Calculate max scale according to allowed crop. + // Formula: + // ( 100 - crop ) visible window_width x scale x video_heigth + // -------------- = ------- = ----------------------------------- + // 100 scaled_size (scale)^2 x video_width x video_height + // + TInt dScaleFactor = ( maxWidth * 100 * KBubbleVideoIACoef ) / + ( (100 - KBubbleMaxVideoCrop) * aVideoFrameSize.iWidth ); + + + TInt scaledHeight = + DivideAndCeil( ( dScaleFactor * aVideoFrameSize.iHeight ), + KBubbleVideoIACoef ); + + // Limit to window height + if ( scaledHeight > aWindowSize.iHeight ) + { + scaledHeight = aWindowSize.iHeight; + dScaleFactor = ( KBubbleVideoIACoef * aWindowSize.iHeight ) / + aVideoFrameSize.iHeight; + } + + TInt scaledWidth = + DivideAndCeil( ( dScaleFactor * aVideoFrameSize.iWidth ), + KBubbleVideoIACoef ); + + aClipSize = TSize( maxWidth, scaledHeight ); + aScreenSize = TSize( scaledWidth + ( 2 * KBubbleVideoClipMarginX ), + scaledHeight + ( 2 * KBubbleVideoClipMarginY ) ); + } + } + +// ============================================================================ +// Callbacks from VideoPlayerutility +// ============================================================================ + +// ---------------------------------------------------------------------------- +// see MVideoPlayerUtilityObserver::MvpuoOpenComplete +// ---------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::MvpuoOpenComplete( TInt aError ) + { + BUBBLE_PRINTF("VideoPlayer::OpenComp:", aError); + if ( aError == KErrNone ) + { + // Prepare clip for playing + iPlayerState = EVideoPreparing; + iVideoPlayer->Prepare(); + } + else // Report error + { + iPlayerState = EVideoError; + iObserver.HandleVideoPlayerError( + MBubbleVideoPlayerObserver::EVideoPlayerInitializingFailure, + aError ); + } + } + +// ---------------------------------------------------------------------------- +// see MVideoPlayerUtilityObserver::MvpuoPrepareComplete +// ---------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::MvpuoPrepareComplete( TInt aError ) + { + BUBBLE_PRINTF("VideoPlayer::PrepComp:", aError); + if ( aError == KErrNone ) + { + iPlayerState = EVideoReady; + iObserver.HandleVideoPlayerInitComplete(); + + SetVolume( iVolume ); + SetRingingType( iRingingType ); + + if ( iToBePlayed ) + { + iVideoPlayer->Play(); + iPlayerState = EVideoPlaying; + } + } + else // Report error + { + iPlayerState = EVideoError; + iObserver.HandleVideoPlayerError( + MBubbleVideoPlayerObserver::EVideoPlayerInitializingFailure, + aError ); + } + } + +// ---------------------------------------------------------------------------- +// see MVideoPlayerUtilityObserver::MvpuoFrameReady +// ---------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::MvpuoFrameReady( CFbsBitmap& /*aFrame*/, + TInt /*aError*/ ) + { + // NOP + } + +// ---------------------------------------------------------------------------- +// see MVideoPlayerUtilityObserver::MvpuoPlayComplete +// ---------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::MvpuoPlayComplete( TInt aError ) + { + BUBBLE_PRINTF("VideoPlayer::PlayComp:", aError); + if ( aError == KErrNone ) + { + iPlayerState = EVideoReady; + + if ( iRingingType == ETypeRingingOnce ) + { + iObserver.HandleVideoPlayerPlayingComplete(); + } + else // continue playing + { + if ( !iRepeatsTrailPauseTimer ) + { + iRepeatsTrailPauseTimer = + CPeriodic::New( CActive::EPriorityStandard ); + } + + if ( iRepeatsTrailPauseTimer && + !iRepeatsTrailPauseTimer->IsActive() ) + { + TCallBack cb( RepeatsTrailPauseTimerCallback, this ); + iRepeatsTrailPauseTimer->Start( KBubbleVideoRepeatsTrailPause, + KBubbleVideoRepeatsTrailPause, + cb ); + } + } + } + else // report error + { + iPlayerState = EVideoError; + iObserver.HandleVideoPlayerError( + MBubbleVideoPlayerObserver::EVideoPlayerPlayingFailure, + aError ); + } + } + +// ---------------------------------------------------------------------------- +// see MVideoPlayerUtilityObserver::MvpuoEvent +// ---------------------------------------------------------------------------- +// +void CBubbleVideoPlayer::MvpuoEvent( const TMMFEvent& /*aEvent*/ ) + { + // NOP + } + + +// End of File