/*

* Copyright (c) 2002-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:  This class is used for playing animated images.

*

*/

//  INCLUDE FILES

#include <jdebug.h>

// For Image Handling Library (IHL)

#include "IHLImageFactory.h"

#include "MIHLFileImage.h"

#include "IHLViewerFactory.h"

#include "MIHLImageViewer.h"

#include "MIHLBitmap.h"

#include "IHLBitmapUtil.h"

// MMAPI includes

#include "mmmadisplay.h"

// Class header

#include "cmmaanimationplayer.h"

#include "cmmaanimationwindow.h"

namespace

{

const TInt64 KMMATimeUnknown = -1;

_LIT(KMMAAnimationContentType, "image/gif");

// Approximated minimum showing time of each frame is 0.12s

// this value basically depends on how fast device can load frames

// it is not quaranteed anyway that the media time is equal to

// clock time, so this needed to be only somewhat close

_LIT(KVideoControlName, "VideoControl");

}

CMMAAnimationPlayer* CMMAAnimationPlayer::NewLC()

{

    DEBUG("MMA::CMMAAnimationPlayer::NewLC");

    CMMAAnimationPlayer* self = new(ELeave) CMMAAnimationPlayer();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

CMMAAnimationPlayer* CMMAAnimationPlayer::NewLC(const TDesC& aFileName)

{

    CMMAAnimationPlayer* self = NewLC();

    self->iFileName = aFileName.AllocL();

    return self;

}

CMMAAnimationPlayer::~CMMAAnimationPlayer()

{

    DEBUG("MMA::CMMAAnimationPlayer::~CMMAAnimationPlayer +");

    if (iViewer && iViewer->IsPlaying())

    {

        iViewer->Stop();

    }

    delete iWindow;

    delete iSnapshotBitmap;

    delete iViewer;

    // viewer has reference to iImage,

    // thus deletion order is important.

    delete iBitmap;

    delete iImage;

    delete iFileName;

    iFSession.Close();

    DEBUG("MMA::CMMAAnimationPlayer::~CMMAAnimationPlayer -");

}

CMMAAnimationPlayer::CMMAAnimationPlayer()

        : iFrameCount(0), iMediaTime(KMMATimeUnknown), iEndReached(EFalse),

        iSendEndOfMediaOnNextFrame(EFalse)

{

}

void CMMAAnimationPlayer::ConstructL()

{

    DEBUG("MMA::CMMAAnimationPlayer::ConstructL +");

    CMMAPlayer::ConstructL();

    HBufC* contentType = KMMAAnimationContentType().AllocL();

    SetContentType(contentType);

    // Connect to file session, needed also when playing from data

    User::LeaveIfError(iFSession.Connect());

    // File session must be share protected for IHL

    User::LeaveIfError(iFSession.ShareProtected());

    DEBUG("MMA::CMMAAnimationPlayer::ConstructL -");

}

void CMMAAnimationPlayer::SetPlayerListenerObjectL(

    jobject aListenerObject,

    JNIEnv* aJni,

    MMMAEventPoster* aEventPoster)

{

    CMMAPlayer::SetPlayerListenerObjectL(aListenerObject,

                                         aJni,

                                         aEventPoster);

    // this method must be called only ones

    __ASSERT_DEBUG(!iWindow, User::Invariant());

    // create window for animationplayer

    // event poster is always CMMAEventSource type.

    iWindow = CMMAAnimationWindow::NewL(

                  static_cast< CMMAEventSource* >(iEventPoster));

}

void CMMAAnimationPlayer::RealizeL()

{

    DEBUG("MMA::CMMAAnimationPlayer::RealizeL");

    // For file locator file must be prefetched here because

    // FramePositioningControl must know duration of media

    // in realized state

    if (iFileName)

    {

        TRAPD(err, PrefetchFileL());

        if (err != KErrNone)

        {

            User::Leave(err);

        }

    }

    CMMAPlayer::RealizeL();

}

void CMMAAnimationPlayer::PrefetchL()

{

    DEBUG("MMA::CMMAAnimationPlayer::PrefetchL +");

    __ASSERT_DEBUG((iSourceStreams.Count() > 0) || iFileName, User::Invariant());

    if (iFileName)

    {

        // file data is already fetched in when realizing

        // If initDisplayMode was called before prefetch,

        // then the display must notified about source size.

        if (iDisplay)

        {

            iDisplay->SourceSizeChanged(iSourceSize);

            NotifyWithStringEvent(CMMAPlayerEvent::ESizeChanged, KVideoControlName);

        }

        ChangeState(EPrefetched);

        PostActionCompleted(KErrNone);

    }

    else

    {

        // Using TDes -- load the whole animation

        iSourceStreams[ 0 ]->ReadAllL();

    }

    // CMMASourceStream will notify with ReadCompleted

    DEBUG("MMA::CMMAAnimationPlayer::PrefetchL -");

}

void CMMAAnimationPlayer::StartL(TBool aPostEvent)

{

    DEBUG("MMA::CMMAAnimationPlayer::StartL +");

    // If end of media has been reached, then

    // start from beginning

    if (iEndReached)

    {

        iEndReached = EFalse;

        iViewer->SetAnimationFrame(0);

        iMediaTime = 0;

    }

    if (aPostEvent)

    {

        PostLongEvent(CMMAPlayerEvent::EStarted, iMediaTime);

    }

    // process current frame

    ProcessCurrentFrameL();

    // progress to next frame (start playback) only if rate is not zero

    if (iCurrentRate > 0)

    {

        iViewer->Play();

    }

    ChangeState(EStarted);

    PostActionCompleted(KErrNone);   // java start return

    DEBUG("MMA::CMMAAnimationPlayer::StartL -");

}

void CMMAAnimationPlayer::ProcessCurrentFrameL()

{

    if (iSendEndOfMediaOnNextFrame)

    {

        iSendEndOfMediaOnNextFrame = EFalse;

        // we are reached the end

        if (!iRepeatForever)

        {

            iRepeatCount++;

            if (iRepeatCount >= iRepeatNumberOfTimes)

            {

                DEBUG("CMMAAnimationPlayer:ProcessCurrentFrameL: Reached repeat count, Stopping");

                // end looping, do not send stopped event

                StopL(EFalse);

                iViewer->SetAnimationFrame(iFrameCount - 1);

                SetLoopCount(iRepeatNumberOfTimes);   // reset loop count

                // Signal that end of media has been reached so on next

                // start playback will be started from beginning. This is needed

                // because if user sets media time to end of media, then start

                // should not start from beginning but just deliver end of media.

                // After that, the next start should start from beginning.

                iEndReached = ETrue;

            }

        }

        PostLongEvent(CMMAPlayerEvent::EEndOfMedia, iMediaTime);

        DEBUG("CMMAAnimationPlayer:ProcessCurrentFrameL: sent END_OF_MEDIA");

        // Prevents this frame from being viewed if playback has terminated

        // (e.g. not looping)

        if (iEndReached)

        {

            return;

        }

    }

    // draw current frame to display if we have it

    if (iDisplay)

    {

        const CFbsBitmap& bitmap = iBitmap->Bitmap();

        iDisplay->DrawFrameL(&bitmap);

    }

    TInt currentFrame = iViewer->AnimationFrame();

    if (currentFrame == 0)

    {

        DEBUG("CMMAAnimationPlayer:ProcessCurrentFrameL: Reset mediatime");

        // reset media time when looping

        iMediaTime = 0;

    }

    iMediaTime += FrameDuration(currentFrame).Int();

    // Media time has gone over duration if user has

    // set media time explicitely to duration.

    if (iMediaTime > iDuration)

    {

        iMediaTime = iDuration;

    }

    if (currentFrame == (iFrameCount - 1))

    {

        // End has been reached, so EndOfMedia is sent when

        // duration of last frame has passed

        iSendEndOfMediaOnNextFrame = ETrue;

    }

    // inform observer

    if (iAnimationObserver)

    {

        iAnimationObserver->AnimationAdvancedL(iViewer->AnimationFrame(), iMediaTime);

    }

}

void CMMAAnimationPlayer::StopL(TBool aPostEvent)

{

    DEBUG("MMA::CMMAAnimationPlayer::StopL +");

    iViewer->Stop();

    // adjust mediatime

    if (aPostEvent)

    {

        PostLongEvent(CMMAPlayerEvent::EStopped, iMediaTime);

    }

    ChangeState(EPrefetched);

    DEBUG("MMA::CMMAAnimationPlayer::StopL -");

}

void CMMAAnimationPlayer::DeallocateL()

{

    DEBUG("MMA::CMMAAnimationPlayer::DeallocateL +");

    // If player is in starte state when deallocate is called,

    // player is stopped from java side -> state is changed to

    // prefetched.

    if (iViewer)

    {

        if (iViewer->IsPlaying())

            iViewer->Stop();

        delete iViewer;

        iViewer = NULL;

    }

    if (iState == EPrefetched)

    {

        ResetSourceStreams();

        iEndReached = EFalse;

        iSendEndOfMediaOnNextFrame = EFalse;

        ChangeState(ERealized);

    }

    DEBUG("MMA::CMMAAnimationPlayer::DeallocateL -");

}

void CMMAAnimationPlayer::GetDuration(TInt64* aDuration)

{

    *aDuration = iDuration;

}

TInt CMMAAnimationPlayer::FindFrame(TInt64 aTime)

{

    __ASSERT_DEBUG(iImage, User::Invariant());

    // if we are out of bounds

    if (aTime > iDuration)

    {

        return KErrNotFound;

    }

    TInt64 time = 0;

    TInt fIndex = 0;

    while ((time < aTime) && (fIndex < iFrameCount))

    {

        time += FrameDuration(fIndex++).Int();

    }

    // adjust to previous frame

    if (fIndex > 0)

    {

        fIndex--;

    }

    return fIndex;

}

TInt64 CMMAAnimationPlayer::MediaTimeForFrame(TInt aFrameIndex)

{

    __ASSERT_DEBUG((aFrameIndex <= iFrameCount) && (aFrameIndex >= 0),

                   User::Invariant());

    TInt64 time = 0;

    for (TInt fIndex = 0; fIndex < aFrameIndex; fIndex++)

    {

        time += FrameDuration(fIndex).Int();

    }

    return time;

}

TTimeIntervalMicroSeconds32 CMMAAnimationPlayer::FrameDuration(TInt aFrameIndex)

{

    __ASSERT_DEBUG(iImage, User::Invariant());

    TTimeIntervalMicroSeconds32 fDur = iImage->AnimationFrameDelay(aFrameIndex);

    const TTimeIntervalMicroSeconds32 KMMAMinimumFrameTime = 120000;

    if (fDur < KMMAMinimumFrameTime)

    {

        fDur = KMMAMinimumFrameTime;

    }

    return fDur;

}

void CMMAAnimationPlayer::SetMediaTimeL(TInt64* aTime)

{

    if (!iImage && !iViewer)

    {

        // not yet prefetched

        *aTime = KErrNotSupported;

    }

    else

    {

        // Media time of last frame is not the same as duration of

        // media, so if media time of duration is requested, then it must

        // be given out altough media time of last frame is lower than that.

        if (*aTime >= iDuration)

        {

            User::LeaveIfError(iViewer->SetAnimationFrame(iFrameCount - 1));

            iMediaTime = iDuration;

        }

        else

        {

            TInt frame = FindFrame(*aTime);

            User::LeaveIfError(iViewer->SetAnimationFrame(frame));

            iMediaTime = MediaTimeForFrame(frame);

        }

        *aTime = iMediaTime;

        iEndReached = EFalse;

        iSendEndOfMediaOnNextFrame = EFalse;

    }

}

void CMMAAnimationPlayer::GetMediaTime(TInt64* aMediaTime)

{

    *aMediaTime = iMediaTime;

}

const TDesC& CMMAAnimationPlayer::Type()

{

    return KMMAVideoPlayer;

}

void CMMAAnimationPlayer::ReadCompletedL(TInt aStatus, const TDesC8& aData)

{

    if (aStatus < KErrNone)

    {

        PostActionCompleted(aStatus);

    }

    else

    {

        TRAPD(err, PrefetchDataL(aData));

        if (err == KErrNone)

        {

            ChangeState(EPrefetched);

        }

        PostActionCompleted(err);

    }

}

void CMMAAnimationPlayer::PrefetchFileL()

{

    iImage = IHLImageFactory::OpenFileImageL(iFSession, *iFileName);

    PrepareViewerL();

}

void CMMAAnimationPlayer::PrefetchDataL(const TDesC8& aData)

{

    DEBUG_INT("MMA::CMMAAnimationPlayer::PrefetchDataL aData size %d",

              aData.Size());

    // Create source image from data

    iImage = IHLImageFactory::OpenBufferedFileImageL(iFSession, aData);

    PrepareViewerL();

}

TBool CMMAAnimationPlayer::IsFilePlayer()

{

    if (iFileName != NULL)

    {

        return ETrue;

    }

    return EFalse;

}

void CMMAAnimationPlayer::PrepareViewerL()

{

    // Non-animated gifs are not supported

    if (!(iImage->IsAnimation()))

    {

        User::Leave(KErrNotSupported);

    }

    // Store image dimensions

    iSourceSize = iImage->Size();

    // Create destination bitmap

    iBitmap = IHLBitmap::CreateL();

    User::LeaveIfError(iBitmap->Create(iSourceSize, iImage->DisplayMode()));

    // Create image viewer

    iViewer = IHLViewerFactory::CreateImageViewerL(

                  iSourceSize,

                  *iImage, // source

                  *iBitmap, // destination

                  *this);  // reference to MIHLViewerObserver

    // Set viewer for window

    iWindow->SetViewer(iViewer);

    // Store animation frame count locally

    iFrameCount = iViewer->AnimationFrameCount();

    // calculate duration

    iDuration = MediaTimeForFrame(iFrameCount);

    // set media time to begin

    iMediaTime = 0;

    // If init has been already done

    if (iDisplay)

    {

        iDisplay->SourceSizeChanged(iSourceSize);

        NotifyWithStringEvent(CMMAPlayerEvent::ESizeChanged, KVideoControlName);

    }

}

MIHLImageViewer* CMMAAnimationPlayer::Viewer()

{

    return iViewer;

}

void CMMAAnimationPlayer::SetAnimationObserver(MMMAAnimationObserver* aAnimationObserver)

{

    iAnimationObserver = aAnimationObserver;

}

TInt CMMAAnimationPlayer::SetRateL(TInt aRate)

{

    DEBUG("MMA:CMMAAnimationPlayer::SetRateL");

    if ((iState == EStarted) && (iCurrentRate != aRate))

    {

        if (aRate <= 0)

        {

            iViewer->Stop();

        }

        else

        {

            iViewer->Play();

        }

    }

    iCurrentRate = aRate;

    return iCurrentRate;

}

TInt CMMAAnimationPlayer::RateL()

{

    DEBUG("MMA:CMMAAnimationPlayer::RateL");

    return iCurrentRate;