/*

* Copyright (c) 2002-2006 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:  

*       SMIL Player media renderer for playing video files

*

*/

// INCLUDE FILES

#include "SmilVideoRenderer.h"

#include <AknUtils.h>

#include <aknlayout.cdl.h>

#include <applayout.cdl.h> // LAF

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknStatuspaneUtils.h>

#include <mmf/common/mmcaf.h>

#include <mmferrors.h>

#include <AudioPreference.h>

#include <smilpresentation.h>

#ifdef VIDEO_DEBUG

    #include "SmilMediaLogging.h"

#endif

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TInt KProcessingDelayOffset = 1 * 1000 * 1000; // 1s

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

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

// CSmilVideoRenderer::CSmilVideoRenderer

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

//

CSmilVideoRenderer::CSmilVideoRenderer( MSmilMedia* aMedia,

                                        DRMCommon& aDrmCommon,

                                        CDRMHelper& aDrmHelper ) :

    CSmilMediaRendererBase( EMsgMediaVideo, aMedia, aDrmCommon, aDrmHelper ),

    iState( ENotReady ),

    iError( KErrNone ),

    iStartTime( TInt64( 0 ) ),

    iParent( aMedia->Presentation()->GetPlayer()->GetControl( aMedia->Presentation() ) )

    {

    }

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

// CSmilVideoRenderer::ConstructL

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

//

void CSmilVideoRenderer::ConstructL( RFile& aFileHandle )

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_ENTERFN( "Video, ConstructL" );

#endif

    BaseConstructL( aFileHandle );

    User::LeaveIfError( CheckDRMRights() );

    User::LeaveIfError( iMediaFile.Duplicate( aFileHandle ) );

    CreateWindowL( iParent );

    Window().SetBackgroundColor( KRgbBlack );

    Window().SetNonFading( ETrue );

    SetRect( ControlRect() );

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, control rect: ( %d, %d) ( %d, %d)"),

        Rect().iTl.iX, Rect().iTl.iY, Rect().iBr.iX, Rect().iBr.iY );

    TPoint winPos = Window().Position();

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, window position: ( %d, %d)"),

        winPos.iX, winPos.iY );

#endif

    //Lets set the video mode according to the platform

    LoadVideoL();

    TInt volume( iMedia->Presentation()->Volume() );

    TRAP_IGNORE( DoSetVolumeL( volume ) );

    MakeVisible( EFalse );

    ActivateL();

#ifdef VIDEO_DEBUG

    SMILUILOGGER_LEAVEFN( "Video: ConstructL" );

    SMILUILOGGER_WRITEF( _L(""));

#endif

    }

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

// CSmilVideoRenderer::NewL

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

//

CSmilVideoRenderer* CSmilVideoRenderer::NewL( RFile& aFileHandle,

                                              MSmilMedia* aMedia,

                                              DRMCommon& aDrmCommon,

                                              CDRMHelper& aDrmHelper )

    {

    CSmilVideoRenderer* renderer = new(ELeave) CSmilVideoRenderer( aMedia,

                                                                   aDrmCommon,

                                                                   aDrmHelper );

    CleanupStack::PushL( renderer );

    renderer->ConstructL( aFileHandle );

    CleanupStack::Pop( renderer );

    return renderer;

    }

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

// CSmilVideoRenderer::~CSmilVideoRenderer

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

//

CSmilVideoRenderer::~CSmilVideoRenderer()

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_ENTERFN( "Video, ~CSmilVideoRenderer" );

#endif

    if ( iVideoPlayer )

        {

#ifdef VIDEO_DEBUG

        SMILUILOGGER_WRITE( "Video: iVideoPlayer->Close()" );

#endif

        iVideoPlayer->Close();

        delete iVideoPlayer;

        }

    iMediaFile.Close();

    iMedia = NULL; // For LINT

#ifdef VIDEO_DEBUG

    SMILUILOGGER_LEAVEFN( "Video: ~CSmilVideoRenderer" );

    SMILUILOGGER_WRITEF( _L(""));

#endif

    }

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

// CSmilVideoRenderer::LoadVideoL

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

//

void CSmilVideoRenderer::LoadVideoL()

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_ENTERFN( "Video: LoadVideoL" );

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

#endif

    // Clipping rect and rect are always relative to screen coordinates!!

    TRect rect( VideoRect() );    

    TRect clipRect( rect );

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("Video: LoadVideo rect before adjusting: (%d, %d) (%d, %d)"),

        rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY );

#endif

    AdjustRects( rect, clipRect );

    if ( !iVideoPlayer )

        {

#ifdef VIDEO_DEBUG

        SMILUILOGGER_WRITEF( _L("SMILUI: Video, rect: ( %d, %d) ( %d, %d), clipRect: ( %d, %d) ( %d, %d)"),

            rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY,

            clipRect.iTl.iX, clipRect.iTl.iY, clipRect.iBr.iX, clipRect.iBr.iY );

#endif

        // Create VideoPlayerUtility instance

        iVideoPlayer = CVideoPlayerUtility::NewL( *this,

                                                  TMdaPriority( KAudioPrioritySmilPlayer ),

                                                  TMdaPriorityPreference( KAudioPrefSmilPlayer ),

                                                  ControlEnv()->WsSession(),

                                                  *ControlEnv()->ScreenDevice(),

                                                  Window(),

                                                  rect,

                                                  clipRect );

        iCurrentClipRect = clipRect;

        // Register for Loading/rebuffering notices

        iVideoPlayer->RegisterForVideoLoadingNotification( *this );

        }

    else

        {

#ifdef VIDEO_DEBUG

        SMILUILOGGER_WRITE( "Video: iVideoPlayer->Close()" );

#endif

        iVideoPlayer->Close();

        if ( clipRect != iCurrentClipRect )

            {

            iVideoPlayer->SetDisplayWindowL( ControlEnv()->WsSession(),

                                             *ControlEnv()->ScreenDevice(),

                                             Window(),

                                             rect,

                                             clipRect );

            iCurrentClipRect = clipRect;

            }

        }

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITE( "Video: iVideoPlayer->OpenFileL()" );

#endif

    TMMFileHandleSource fileHandleSource( iMediaFile, KDefaultContentObject, ContentAccess::EPeek );

    iVideoPlayer->OpenFileL( fileHandleSource );

    BeginActiveWait();

    MMMFDRMCustomCommand* customCommand = iVideoPlayer->GetDRMCustomCommand();

    if ( customCommand )

        {

        customCommand->DisableAutomaticIntent( ETrue );            

        }

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, iError = %d"), iError );

#endif

    if ( iError != KErrNone )

        {

        User::Leave( iError );

        }

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

    SMILUILOGGER_LEAVEFN( "Video: LoadVideoL" );

#endif

    }

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

// CSmilVideoRenderer::DoSetVolumeL

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

//

void CSmilVideoRenderer::DoSetVolumeL( TInt aVolume )

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_ENTERFN( "Video: DoSetVolumeL" );

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, aVolume = %d"), aVolume );

#endif

    if ( iVideoPlayer->AudioEnabledL() )

        {

#ifdef VIDEO_DEBUG

        SMILUILOGGER_WRITE( "Video: iVideoPlayer->SetVolumeL()" );

#endif

        iVideoPlayer->SetVolumeL( iVideoPlayer->MaxVolume() * aVolume / 100 );

        }

#ifdef VIDEO_DEBUG

    SMILUILOGGER_LEAVEFN( "Video: DoSetVolumeL" );

    SMILUILOGGER_WRITEF( _L(""));

#endif

    }

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

// CSmilVideoRenderer::IsVisual

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

//

TBool CSmilVideoRenderer::IsVisual() const

    {

    return ETrue;

    }

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

// CSmilVideoRenderer::IsOpaque

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

//

TBool CSmilVideoRenderer::IsOpaque() const

    {

    return ETrue;

    }

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

// CSmilVideoRenderer::IntrinsicWidth

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

//

TInt CSmilVideoRenderer::IntrinsicWidth() const

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, IntrinsicWidth = %d"),

                         iMedia->GetRectangle().Width() );

    SMILUILOGGER_WRITEF( _L(""));

#endif

    return iMedia->GetRectangle().Width();

    }

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

// CSmilVideoRenderer::IntrinsicHeight

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

//

TInt CSmilVideoRenderer::IntrinsicHeight() const

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, IntrinsicHeight = %d"),

                         iMedia->GetRectangle().Height() );

    SMILUILOGGER_WRITEF( _L(""));

#endif

    return iMedia->GetRectangle().Height();

    }

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

// CSmilVideoRenderer::IntrinsicDuration

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

//

TSmilTime CSmilVideoRenderer::IntrinsicDuration() const

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_ENTERFN( "Video: IntrinsicDuration" );

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

#endif

    TTimeIntervalMicroSeconds duration( TInt64( 0 ) );

    TRAPD( error, duration = iVideoPlayer->DurationL() );

    if ( error == KErrNone )

        {

        duration = duration.Int64() + iProcessingDelay.Int64() + KProcessingDelayOffset;

        }

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, IntrinsicDuration = %d"), I64INT( duration.Int64() ) );

    SMILUILOGGER_LEAVEFN( "Video: IntrinsicDuration" );

    SMILUILOGGER_WRITEF( _L(""));

#endif

    return TSmilTime::FromMicroSeconds( duration );

    }

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

// CSmilVideoRenderer::PrepareMediaL

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

//

void CSmilVideoRenderer::PrepareMediaL()

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_ENTERFN( "Video: PrepareMediaL" );

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

#endif

    if ( iState == EReady )

        {

        // Parent control position might have changed so we need to

        // update our position & size.

        SetRect( ControlRect() );

        }

    // Reset processing delay.    

    iProcessingDelay = TInt64( 0 );

    // Reset pause position.

    iPausePosition = TInt64( 0 );

    if ( iLatePreparation )

        {

#ifdef VIDEO_DEBUG

        SMILUILOGGER_WRITEF( _L("SMILUI: Using late preparation") );

#endif

        DoLatePreparationL();

        if ( iError != KErrNone )

            {            

            iState = EError;

            }

        }

    if ( iState == EReady )

        {

        iState = EHidden;

        } 

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

    SMILUILOGGER_LEAVEFN( "Video: PrepareMediaL" );

    SMILUILOGGER_WRITEF( _L(""));

#endif

    }

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

// CSmilVideoRenderer::SeekMediaL

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

//

void CSmilVideoRenderer::SeekMediaL( const TSmilTime& aTime )

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_ENTERFN( "Video: SeekMediaL" );

    SMILUILOGGER_WRITEF( _L("SMILUI: Video: SeekMediaL, time=%d"), aTime.Value() );

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

#endif

    TTimeIntervalMicroSeconds position = iVideoPlayer->PositionL();

    if ( position != aTime.ToMicroSeconds() )

        {

        if ( iState == EPlaying )

            {

#ifdef VIDEO_DEBUG

            SMILUILOGGER_WRITEF( _L("Video: iVideoPlayer->Stop()") );

#endif

            iVideoPlayer->Stop();

#ifdef VIDEO_DEBUG

            SMILUILOGGER_WRITEF( _L("Video: iVideoPlayer->SetPositionL()" ));

#endif

            iVideoPlayer->SetPositionL( aTime.ToMicroSeconds() );

#ifdef VIDEO_DEBUG

            SMILUILOGGER_WRITEF( _L("Video: iVideoPlayer->Play()") );

#endif

            iVideoPlayer->Play();

            }

        else if( iState == EHidden )

            {

#ifdef VIDEO_DEBUG

            SMILUILOGGER_WRITEF( _L("Video: iVideoPlayer->SetPositionL()") );

#endif

            iVideoPlayer->SetPositionL( aTime.ToMicroSeconds() );

            }

        }

    if( aTime == 0 &&  

        iState == EPaused &&

        PresentationPlaying() )

        {

#ifdef VIDEO_DEBUG

        SMILUILOGGER_WRITE( "SMILUI: Video, Auto play on SeekMediaL" );

#endif

        iState = EHidden;

        ShowMediaL();

        }

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

    SMILUILOGGER_LEAVEFN( "Video: SeekMediaL" );

    SMILUILOGGER_WRITEF( _L(""));

#endif

    }

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

// CSmilVideoRenderer::ShowMediaL

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

//

void CSmilVideoRenderer::ShowMediaL()

    {

#ifdef VIDEO_DEBUG

    SMILUILOGGER_ENTERFN( "Video: ShowMediaL" );

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

#endif

    if ( iState == EHidden )

        {

        iState = ELoading;

        UpdateDrawingArea();

        MakeVisible( ETrue );

#ifdef VIDEO_DEBUG

        SMILUILOGGER_WRITEF( _L("Video: iCurrentClipRect: (%d, %d) (%d, %d)"),

            iCurrentClipRect.iTl.iX, iCurrentClipRect.iTl.iY, iCurrentClipRect.iBr.iX, iCurrentClipRect.iBr.iY );

        SMILUILOGGER_WRITE( "Video: iVideoPlayer->Play()" );

#endif

        iCoeEnv->WsSession().Flush();

        iStartTime.HomeTime();

        if ( iMedia->Presentation()->State() != CSmilPresentation::EPlaying )

			{

			iOldVolume = iVideoPlayer->Volume();	

			SetVolume( 0 );

			}       

        iVideoPlayer->Play();

        // To make sure we don't Pause before clip has been loaded.

        BeginActiveWait();

        if ( iState == ELoading )

            {

            iState = EPlaying;

            TTime stopTime( TInt64( 0 ) );

            stopTime.HomeTime();

            iProcessingDelay = iProcessingDelay.Int64() + stopTime.MicroSecondsFrom( iStartTime ).Int64();

            ConsumeDRMRightsL();

            }

        }

#ifdef VIDEO_DEBUG

    SMILUILOGGER_WRITEF( _L("SMILUI: Video, State = %d"), iState );

    SMILUILOGGER_LEAVEFN( "Video: ShowMediaL" );

    SMILUILOGGER_WRITEF( _L(""));

#endif

    }

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

// CSmilVideoRenderer::HideMedia