/*

* Copyright (c) 2007,2009 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 playback time for rendering state machine

*

*/

// INCLUDES

#include "upnprenderingplaytimecalculator.h"

_LIT( KComponentLogfile, "upnprenderingstatemachine.txt");

#include "upnplog.h"

// CONSTANTS

const TInt KMicrosecondsInMillisecond = 1000;

const TInt KMillisecondsInSecond = 1000;

const TInt KDurationErrorMargin = 3000; // 3 seconds

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

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

// CUpnpRenderingPlaytimeCalculator::CUpnpRenderingPlaytimeCalculator

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

//

CUpnpRenderingPlaytimeCalculator::CUpnpRenderingPlaytimeCalculator()

    {

    iPlaying = EFalse;

    iPaused = EFalse;

    iStartMark = 0;

    iStopMark = 0;

    iPauseMark = 0;

    iPauseTime = 0;

    iOffset = 0;

    iDuration = KErrNotFound;

    }

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

// CUpnpRenderingPlaytimeCalculator::Start

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

//

void CUpnpRenderingPlaytimeCalculator::Start()

    {

    __LOG("PlaytimeCalculator: Start()" );

    iStartMark.UniversalTime();

    iPauseTime = 0;

    iPlaying = ETrue;

    iPaused = EFalse;

    iOffset = 0;

    }

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

// CUpnpRenderingPlaytimeCalculator::Pause

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

//

void CUpnpRenderingPlaytimeCalculator::Pause()

    {

    __LOG("PlaytimeCalculator: Pause()" );

    if( !iPaused )

        {

        iPauseMark.UniversalTime();

        iPaused = ETrue;

        }

    }

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

// CUpnpRenderingPlaytimeCalculator::Resume

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

//

void CUpnpRenderingPlaytimeCalculator::Resume()

    {

    __LOG("PlaytimeCalculator: Resume()" );

    TTime resumeMark;

    resumeMark.UniversalTime();

    iPauseTime += PausetimeAt( resumeMark );

    iPaused = EFalse;

    }

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

// CUpnpRenderingPlaytimeCalculator::Stop

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

//

void CUpnpRenderingPlaytimeCalculator::Stop()

    {

    __LOG("PlaytimeCalculator: Stop()" );

    iStopMark.UniversalTime();

    iPlaying = EFalse;

    }

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

// CUpnpRenderingPlaytimeCalculator::SetDuration

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

//

void CUpnpRenderingPlaytimeCalculator::SetDuration( TInt aDuration )

    {

    iDuration = aDuration;

    __LOG1("PlaytimeCalculator:SetDuration iDuration %d", iDuration );

    }

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

// CUpnpRenderingPlaytimeCalculator::Duration

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

//

TInt CUpnpRenderingPlaytimeCalculator::Duration() const

    {

    __LOG1("PlaytimeCalculator: iDuration %d", iDuration );

    return iDuration;

    }

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

// CUpnpRenderingPlaytimeCalculator::AcknowledgePositionInfo

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

//

void CUpnpRenderingPlaytimeCalculator::AcknowledgePositionInfo(

    TInt aDuration, TInt aPosition )

    {

    __LOG3("PlaytimeCalculator::AcknowledgePositionInfo \

aDuration %d aPosition %d, iPlaying %d ", 

    aDuration, aPosition, iPlaying );

    // handle DURATION

    if ( aDuration > 0 )

        {

        if ( iDuration <= 0)

            {

            // we did not know duration before, set it

            iDuration = aDuration;

            }

        else if ( aDuration > iDuration )

            {

            // renderer thinks track is longer. trust longer value!

            // too long is more safe than too short.

            // TOO LONG -> playlist play may discontinue. (annoying)

            // TOO SHORT -> pressing stop may cause track skip and

            //              user can't stop the music (critical)

            iDuration = aDuration;

            }

        }

    // handle POSITION

    if ( iPlaying )

        {

        // calculate playtime now, compare to given position

        // and manipulate offset accordingly

        iOffset = OffsetFromNow( aPosition );

        __LOG1("PlaytimeCalculator: New Offset %d", iOffset );

        }

    else

        {

        // start timer and set position according to ongoing playback

        Start();

        TTimeIntervalSeconds origPos = aPosition / KMillisecondsInSecond;

        iStartMark -= origPos;

        iOffset = OffsetFromNow( aPosition );

        }

    __LOG2("PlaytimeCalculator::AcknowledgePositionInfo \

iDuration %d Current Position %d ", iDuration, Position() );

    }

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

// CUpnpRenderingPlaytimeCalculator::Position

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

//

TInt CUpnpRenderingPlaytimeCalculator::Position() const

    {

    TTime tempTime;

    if ( iPlaying )

        {

        __LOG("PlaytimeCalculator: Position() - using current time" );

        // measure time until NOW.

        tempTime.UniversalTime();

        }

    else

        {

        // measure time until last track STOPPED.

        tempTime = iStopMark;

        }        

    return PositionAt( tempTime );

    }

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

// CUpnpRenderingPlaytimeCalculator::IsTrackComplete

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

//

TBool CUpnpRenderingPlaytimeCalculator::IsTrackComplete() const

    {

    TBool isCompleted = ETrue;

    TInt playtime = Position();

    if ( playtime >= 0 &&

        playtime < iDuration - KDurationErrorMargin )

        {

        // [0 - duration-margin]

        isCompleted= EFalse;

        }

    else if ( playtime >= iDuration - KDurationErrorMargin &&

        playtime <= iDuration + KDurationErrorMargin )

        {

        // [duration-margin - duration+margin]

        isCompleted= ETrue;

        }

    else

        {

        // position either negative or greater than duration ??

        __LOG2("PlaytimeCalculator: WARNING: playtime=%d duration=%d",

            playtime,

            iDuration );

        isCompleted= ETrue;

        }

    return isCompleted;

    }

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

// CUpnpRenderingPlaytimeCalculator::IsPlaying

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

//

TBool CUpnpRenderingPlaytimeCalculator::IsPlaying() const

    {

    return iPlaying;

    }

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

// CUpnpRenderingPlaytimeCalculator::RestartAt

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

//

void CUpnpRenderingPlaytimeCalculator::RestartAt( TInt aNewPosition )

    {

    __LOG("PlaytimeCalculator: RestartAt()" );

    Stop();

    Start();

    // Consider new position to be equivalent to current position

    TTimeIntervalSeconds newPos = 

            aNewPosition / KMillisecondsInSecond;

    iStartMark -= newPos;

    }

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

// CUpnpRenderingPlaytimeCalculator::PositionAt

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

//

TInt CUpnpRenderingPlaytimeCalculator::PositionAt( TTime& aMark ) const

    {

    TTimeIntervalMicroSeconds played =

        aMark.MicroSecondsFrom( iStartMark );

    TInt playtime = ( played.Int64() / KMicrosecondsInMillisecond );

    __LOG1("PlaytimeCalculator: PositionAt played %d", playtime );

    playtime -= iPauseTime;

    playtime -= PausetimeAt( aMark );

    playtime += iOffset;

    __LOG3("PlaytimeCalculator: playtime=%d pausetime=%d offset=%d",

        playtime,

        (iPauseTime + PausetimeAt( aMark )),

        iOffset );

    return playtime;

    }

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

// CUpnpRenderingPlaytimeCalculator::PausetimeAt

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

//

TInt CUpnpRenderingPlaytimeCalculator::PausetimeAt( TTime& aMark ) const

    {

    TInt pausetime = 0;

    if ( iPaused )

        {

        TTimeIntervalMicroSeconds latestPause =

            aMark.MicroSecondsFrom( iPauseMark );

        pausetime = ( latestPause.Int64() / KMicrosecondsInMillisecond );

        __LOG1("PlaytimeCalculator: PausetimeAt pause time %d", pausetime );

        }

    return pausetime;

    }

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

// CUpnpRenderingPlaytimeCalculator::OffsetFromNow

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

//

TInt CUpnpRenderingPlaytimeCalculator::OffsetFromNow( TInt aPosition ) const

    {

    TTime timeNow;

    timeNow.UniversalTime();

    TInt tempPlaytime = PositionAt( timeNow );

    TInt o = aPosition - tempPlaytime;

    __LOG2("PlaytimeCalculator: renderer position (%d), \

tempPlaytime (%d)", aPosition, tempPlaytime );

    __LOG3("PlaytimeCalculator: old off(%d) current off(%d), \

new offset(%d)", iOffset, o, iOffset+o);

    return iOffset+o;

    }

// end of file