/*

* 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 <coemain.h>       // CCoeEnv 

#include <eikenv.h>        // CEikEnv 

#include <videoplayer.h>   // 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<TMdaPriorityPreference>( 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<CBubbleVideoPlayer*>( 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<CBubbleVideoPlayer*>( 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<");           

    }

// -----------------------------------------------------------------------------