// Copyright (c) 2004-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:

//

/** 	@file

	@internalTechnology */

#include <f32file.h>

#include <ecom/ecom.h>

#include "MngChunks.h"

#include "MngReadStream.h"

#include "MngProcessor.h"

#include "PngProcessor.h"

#include "MngRenderer.h"

#include "MngPanic.h"

#include "MngPlayerObserver.h"

#include "StreamDecoderIFace.h"

#include "StreamDecoderIFace.hrh"

#include "icl/imagedisplayplugin.h"

#include "logger.h"

#include "MngPlayer.h"

const CMngPlayer::TObserverNotifyEvent KDecodingStopError	=CImageDisplayPlugin::EStatusNoMoreToDecode

																| CImageDisplayPlugin::EStatusPaused;

const CMngPlayer::TObserverNotifyEvent KNotReadyToDecode	=CImageDisplayPlugin::EStatusBusy;

const CMngPlayer::TObserverNotifyEvent KFrameReady			=CImageDisplayPlugin::EStatusFrameReady;

const CMngPlayer::TObserverNotifyEvent KLastFrameReady		=CImageDisplayPlugin::EStatusFrameReady 

																| CImageDisplayPlugin::EStatusNoMoreToDecode;

const CMngPlayer::TObserverNotifyEvent KFinishedClearOutput	=CImageDisplayPlugin::EStatusEraseOutputContents

																| CImageDisplayPlugin::EStatusNoMoreToDecode;

const CMngPlayer::TObserverNotifyEvent KFinishedKeepOutput	=CImageDisplayPlugin::EStatusDisplayThisFrameIndefinetely

																| CImageDisplayPlugin::EStatusNoMoreToDecode;

const CMngPlayer::TObserverNotifyEvent KFinishedEraseOutputFlag=CImageDisplayPlugin::EStatusEraseOutputContents;

const CMngPlayer::TObserverNotifyEvent KFinishedKeepOutputFlag=CImageDisplayPlugin::EStatusDisplayThisFrameIndefinetely;

const CMngPlayer::TObserverNotifyEvent KInitComplete=0;

/*static*/ 

CMngPlayer*	CMngPlayer::NewL(CMngFileReadStream* aReadStream, MMngPlayerObserver& aObserver, TBool aMngSubframesNoLoops)   //Subframes with No Loops

	{

	CMngPlayer* self=new (ELeave) CMngPlayer(aObserver, aMngSubframesNoLoops);   //Subframes with No Loops

	CleanupStack::PushL(self);

	self->ConstructL(aReadStream);

	CleanupStack::Pop(self);

	return self;

	}

CMngPlayer::CMngPlayer(MMngPlayerObserver& aObserver, TBool aMngSubframesNoLoops):CActive(EPriorityIdle), //Subframes with No Loops

														iMngSubframesNoLoops(aMngSubframesNoLoops),   //Subframes with No Loops

														iObserver(aObserver),

														iPerformFrameDelayInternally(ETrue),

														i1stFrameInterframeDelay(-1),

														iFrameNumberToTerminate(-1),

														iNeedsChange(ETrue)

	{

	CActiveScheduler::Add(this);

	}

void CMngPlayer::ConstructL(CMngFileReadStream* aReadStream)

	{

	TUid DtorKey;

	iDecoderFactory = reinterpret_cast<MImageStreamDecoderFactory*>

							(REComSession::CreateImplementationL(TUid::Uid(KPngStreamDecoderFactoryImplUidValue), DtorKey));

	iDecoderFactory->SetDtorKey(DtorKey);

	iExecTimer		= CDelayTimer::NewL(*this);

	iMngStream		= aReadStream;

	iMngStream->AddRef();

	iMngProcessor	= CMngProcessor::NewL(*this, iMngSubframesNoLoops); //Subframes with No Loops

	iPngProcessor	= CPngProcessor::NewL(*this);

	iMngProcessor->AddSubProcessor(*iPngProcessor);

	}

CMngPlayer::~CMngPlayer()

	{

	Cancel();

	delete iExecTimer;

	if (NULL != iMngProcessor)

		{

		iMngProcessor->Stop();

		}

	delete iMngProcessor;

	delete iPngProcessor;

	if (NULL != iMngStream)

		{

		iMngStream->Release();

		iMngStream = NULL;

		}

	delete iMngRenderer;

	iObjectList.Destroy();

	iLoopStack.Close();

	iChunkProviders.Close();

	delete iMngHeader;

	delete iTerminationCtrl;

	if (NULL != iDecoderFactory)

		{

		iDecoderFactory->Release();

		}

	}

void CMngPlayer::InitL(TMhdrChunk*& aHeaderChunk)

	{

	SetMngHeader(aHeaderChunk);

	if (iGotHeaderFromStream)

		{

		User::Leave(KErrCorrupt);

		}

	iGotHeaderFromStream = ETrue;

	if (iMngHeader->iProfileValidity && (iMngHeader->iJngPresence

#ifdef STRICT_MNG_LC

		|| iMngHeader->iDeltaPngPresence ==1

#endif // STRICT_MNG_LC

		))

		{

		User::Leave(KErrNotSupported);

		}

	iMngRenderer = CMngRenderer::NewL(TSize(iMngHeader->iFrameWidth, iMngHeader->iFrameHeight), 

										IsAlphaNeeded(), iDestDisplayMode, iMaskDisplayMode );

	NotifyObserver(KInitComplete, KErrNone, TTimeIntervalMicroSeconds32(0));

	}

void CMngPlayer::Decode()

	{

	if (iExecTimer->IsActive())

		{

		return; // we'are just awating for delay to elapse

		}

	if (iOutstandingNotify)

		{

		iOutstandingNotify = EFalse;

		iExecTimer->After(TTimeIntervalMicroSeconds32(0));

		iIsPaused = EFalse;

		return;

		}

	switch (iState)

		{

		case EStJustBorn:

			iMngProcessor->Start(*iMngStream, iStatus);

			iMngStream->Release();

			iMngStream	= NULL;

			iState		= EStReadingFormat;

			SetActive();

			break;

		case EStReadingFormat:

			iMngProcessor->Resume();

			break;

		default: 

			if (iIsPaused)

				{

				if (!IsActive() && !iExecTimer->IsActive())

					{

					RunAgain();

					}

				}

			else

				{

				if (iState != EStPlaying)

					{

					StartPlay();

					}

				}

		}

	iIsPaused = EFalse;

	}

void CMngPlayer::StopDecode()

	{

	iOutstandingNotify = EFalse;

	if (iState == EStReadingFormat)

		{

		iMngProcessor->Pause();

		return;

		}

	Cancel();

	if (NULL != iExecTimer)

		{

		iExecTimer->Cancel();

		}

	iIsPaused				= EFalse;

	iFrameNumberToTerminate	=-1;

	i1stFrameInterframeDelay=-1;

	if (EStPlaying == iState)

		{

		iState = EStReadyToPlay;

		}

	if (iTerminationCtrl)

		{

		iTerminationCtrl->Reset();

		}

	}

void CMngPlayer::Pause()

	{

	if (iIsPaused)

		{

		return;

		}

	switch (iState)

		{

		case EStJustBorn:

			break;

		case EStReadingFormat:

			iMngProcessor->Pause();

			break;

		default:

			(void)0;

		}

	iIsPaused = ETrue;

	}

void CMngPlayer::RunL()

	{

	ASSERT(!iExecTimer->IsActive());

	if (KErrNone != iStatus.Int())

		{

		iPlayerErrorCode = iStatus.Int();

		StopDecode();

		iState = EStStopped;

		NotifyObserver(KDecodingStopError, iPlayerErrorCode, TTimeIntervalMicroSeconds32(0));

		return;

		}

	switch (iState)

		{

		case EStJustBorn:

			ASSERT(EFalse);

			break;

		case EStReadingFormat:

			iState = TPlayerState(iState + 1);

			delete iMngProcessor;

			iMngProcessor = NULL;

			if (iMngHeader == NULL)

				{

				User::Leave(KErrCorrupt);

				}

			StartPlay();

			break;

		case EStReadyToPlay:

			ASSERT(EFalse);

			break;

		case EStPlaying:

			OnIteration();

			break;

		case EStStopped:

			ASSERT(EFalse);

			break;

		case EStNeedsRepeat:

			ASSERT(EFalse);

			break;

		}

	}

void CMngPlayer::DoCancel()

	{

	TBool timerActive = EFalse;

	if (NULL != iExecTimer)

		{

		timerActive = iExecTimer->IsActive();

		iExecTimer->Cancel();

		}

	if (NULL != iMngProcessor)

		{

		iMngProcessor->Stop();

		}

	if (!timerActive)

		{

		iStatus = KErrCancel;

		}

	}

TInt CMngPlayer::RunError(TInt aError)

	{

	iPlayerErrorCode= aError;

	iState			= EStStopped;

	NotifyObserver(KDecodingStopError, iPlayerErrorCode, TTimeIntervalMicroSeconds32(0));

	return KErrNone;

	}

void CMngPlayer::RunAgain()

	{

	SetActive();

	TRequestStatus* pReq=&iStatus;

	User::RequestComplete(pReq, KErrNone);

	}

void CMngPlayer::StartPlay()

	{

	if (iState != EStReadyToPlay && iState != EStNeedsRepeat)

		{

		NotifyObserver(KNotReadyToDecode, KErrNotReady, TTimeIntervalMicroSeconds32(0));

		return;

		}

	iNominalDelayBeforeThisFrame = 0;

	iEndOfFrameNotification = EFalse;

	iInterframeDelay		= 0;

	iDefaultInterFrmDelay	= 0;

	iNextInterFrameDelay	= 0;

	if (0 != iMngHeader->iTicksPerSecond)

		{

		iTickLength = 1000000 / iMngHeader->iTicksPerSecond;

		if (0 >= iTickLength)

			{

			iTickLength = 1;

			}

		iInterframeDelay		= 1;

		iDefaultInterFrmDelay	= 1;

		iNextInterFrameDelay	= 1;

		}

	iCurrentObject = iObjectList.Begin();

	iFramingMode=EMngFramNoBgLayerExcpt1stFgLayer;

	iSubframeLayerNum	= 0;

	iDrawnLayerNum		= 0;

	iDrawnFrameNum		= 0;

	iDefaultClippingBnd.iTl.iX = 0;

	iDefaultClippingBnd.iTl.iY = 0;

	iDefaultClippingBnd.iBr.iX = iMngHeader->iFrameWidth;

	iDefaultClippingBnd.iBr.iY = iMngHeader->iFrameHeight;

	iFrameBeingRendered	= EFalse;

	iChunkProviders.Clear();

	iMngRenderer->Reset();

	for (RMngObjectList::TObjectIterator it=iObjectList.Begin(); it != iObjectList.End(); ++it)

		{

		iObjectList[it]->Reset();

		}

	iState = EStPlaying;

	RunAgain();

	}

void CMngPlayer::SetTerminationCtrlL(CMngTermination* aTermination)

	{

	if (NULL != iTerminationCtrl)

		{

		delete aTermination;

		User::Leave(KErrCorrupt);

		}

	iTerminationCtrl = aTermination;

	}

void CMngPlayer::AppendObjectL(CMngObject*& aObject)

	{

	aObject->SetObjectLabel(iObjectList.Count()+1);	

	TInt err=iObjectList.Append(aObject);

	CMngObject* temp=aObject;

	aObject = NULL;

	if (KErrNone != err)

		{

		delete temp;

		User::Leave(err);

		}

	temp->OnAddToPlayerL(*this);

	}

void CMngPlayer::OnEndOfSubFrame()

	{

	if (iChangeInterFrmDelay == EMngFramChangeUpcomingSubFrameOnly)

		{

		if(iObjectList[iCurrentObject+1]->IsSubFrame())

			{

			iNeedsChange = EFalse;

			iInterframeDelay = iNextInterFrameDelay;

			}

		iNextInterFrameDelay = iDefaultInterFrmDelay;

		}

	iChangeInterFrmDelay = EMngFramDoNotChange;

	if (iChangeClippingBoundaries == EMngFramChangeUpcomingSubFrameOnly)

		{

		iCurrentClippingBnd = iDefaultClippingBnd;

		iMngRenderer->SetBgClipRect(iCurrentClippingBnd);

		}

	if (iChangeClippingBoundaries == EMngFramChangeAndResetDefault)

		{

		iDefaultClippingBnd = iCurrentClippingBnd;

		iMngRenderer->SetBgClipRect(iCurrentClippingBnd);

		iMngRenderer->ClearOutputRect();

		}

	iChangeClippingBoundaries = EMngFramDoNotChange;

	if (!iFrameBeingRendered)

		{

		iInterframeDelay = iNextInterFrameDelay;

		}

	iSubframeLayerNum = 0;

	}

void CMngPlayer::OnNewLayer()

	{

	if (iFramingMode==EMngFramBgLayerForEachFgLayer || iDrawnLayerNum==0 ||

		 (iFramingMode==EMngFramBgLayerFor1stFgLayer && iSubframeLayerNum == 0))

		{

		iMngRenderer->ClearOutputRect();

		}

	++iDrawnLayerNum;

	++iSubframeLayerNum;

	iFrameBeingRendered = ETrue;

	}

void CMngPlayer::OnEndOfFrame(TBool aAlwaysNotify, TBool aIsLastFrame)

	{

	const TInt KTimerThreshold =1000;

	++iDrawnFrameNum;

	TUint NotifyCode=(aIsLastFrame? KLastFrameReady : KFrameReady);

	if (iFrameNumberToTerminate >= 0 && iFrameNumberToTerminate==iDrawnFrameNum)

		{

		NotifyCode = (KLastFrameReady|KFinishedKeepOutputFlag);

		}

	const TInt TicksDelay=(iDrawnFrameNum==1 && i1stFrameInterframeDelay>-1 ? i1stFrameInterframeDelay : iInterframeDelay);

	if ( (NotifyCode & KLastFrameReady)==KLastFrameReady)

		{

		StopDecode();

		}

	TInt delayValue=Ticks2TimeInterval(TicksDelay).Int();

	i1stFrameInterframeDelay =-1;

	if (iPerformFrameDelayInternally)

		{

		TTime CurrentTime;

		CurrentTime.HomeTime();

		const TInt KDelayNeeded	=delayValue;

		const TInt KMsDifference=I64HIGH(CurrentTime.MicroSecondsFrom(iEndOfPreviuosFrame).Int64()) ? KDelayNeeded +1 :

									I64LOW( CurrentTime.MicroSecondsFrom(iEndOfPreviuosFrame).Int64() );

		delayValue=KDelayNeeded - KMsDifference > KTimerThreshold ? KDelayNeeded - KMsDifference - KTimerThreshold : 0;

		LOG4("Needed %u Got %u Val %u", KDelayNeeded, KMsDifference, delayValue);

		}

	iEndOfFrameNotification = ETrue;

	if (iInterframeDelay != 0 || aAlwaysNotify )  // as per spec do not send zero-delay updates

		{

		NotifyObserver(NotifyCode, KErrNone, TTimeIntervalMicroSeconds32(delayValue));

		}

	iEndOfPreviuosFrame.HomeTime();

	iFrameBeingRendered	= EFalse;

	if(iNeedsChange)

		{

		iInterframeDelay = iNextInterFrameDelay;

		iNeedsChange = ETrue;

		}

	}

inline

void CMngPlayer::OnIteration()

	{

	if (iIsPaused)

		{

		return;

		}

	TBool CallAgain=EFalse;

	do 

		{

		TRAP(iPlayerErrorCode, CallAgain=DoIterationL());	

		} while (iPlayerErrorCode==KErrNone && CallAgain && !iIsPaused);

	if (KErrNone != iPlayerErrorCode)

		{

		StopDecode();

		iState=EStStopped;

		NotifyObserver(KDecodingStopError, iPlayerErrorCode, TTimeIntervalMicroSeconds32(0));

		}

	}

TBool CMngPlayer::DoIterationL()

	{

	CMngObject* pObject=NULL;

	if (iCurrentObject==iObjectList.End() )

		{

		if (!iLoopStack.IsEmpty())

			{

			User::Leave(KErrCorrupt);

			}

		pObject = iTerminationCtrl;

		}

	else

		{