// 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 <s32mem.h>

#include "Crc32.h"

#include "MngChunks.h"

#include "MngObjects.h"

static const TInt KInt32Size = sizeof(TInt32);

void TMNGChunkHeader::ReadL(MInputStream& aInputStream)

   {

   aInputStream.ReadInt32L(iLength);

   TPtr8 ChunkBf(iChunkId.iChunkIdChr, sizeof(iChunkId) );

   aInputStream.ReadL(ChunkBf);

   if (iLength < 0)

	   {

	   User::Leave( KErrCorrupt);

	   }

   }

void TMngChunk::ReadAndCheckCrcL(MInputStream& aInputStream)

	{

	TInt32 crc;

	aInputStream.ReadInt32L(crc);

	crc^=(~(TUint32)0);

	if (crc != iCalculatedCrc.iCrc)

		{

		User::Leave(KErrCorrupt);

		}

	}

TMngChunk::TObjectFactoryFuncL TMngChunk::MngObjectFactoryFunc() const

	{

	return NULL;

	}

void TMngChunk::ReadNameL(MInputStream& aInputStream,TMngObjectName& aName, TInt aMaxDataSize)

	{

	TText8 LastChar=1;

	aName.Zero();

	TInt i=aMaxDataSize;

	for (; i && LastChar; --i)

		{

		aInputStream.ReadUint8L(LastChar, &iCalculatedCrc.iCrc);

		if (LastChar)

			{

			aName.Append(LastChar);

			}

		}

	if (i==0 && LastChar)

		{

		User::Leave(KErrCorrupt); // buffer overflow

		}

	}

void TUnknownChunk::ReadL(MInputStream& aInputStream)

	{

#ifdef _DEBUG

	for (TInt i=iHeader.iLength; i; --i)

		{

		TText8 dummy;

		aInputStream.ReadUint8L(dummy, &iCalculatedCrc.iCrc);

		}

	ReadAndCheckCrcL(aInputStream);

#else

	aInputStream.SeekL( aInputStream.Tell() + iHeader.iLength + sizeof(iCalculatedCrc) );

#endif

	}

void TMhdrChunk::ReadL(MInputStream& aInputStream)

	{

	if (iHeader.iLength != 28)

		{

		User::Leave(KErrCorrupt);

		}

	aInputStream.ReadInt32L(&iFrameWidth, iHeader.iLength/KInt32Size, &iCalculatedCrc.iCrc);

	ReadAndCheckCrcL(aInputStream);

	if (iZeroBit !=0 || iTicksPerSecond<0 || iFrameWidth <=0 || iFrameHeight <=0 || iNominalPlayTime <0 

		  || iNominalFrameCount <0 || iNominalLayerCount <0 )

		{

		User::Leave(KErrCorrupt);

		}

	}

void TDefiChunk::ReadL(MInputStream& aInputStream)

	{

	if (iHeader.iLength <2 || (iHeader.iLength >4 && iHeader.iLength !=12 && iHeader.iLength !=28))

		{

		User::Leave(KErrCorrupt);

		}

	TUint16 temp;

	aInputStream.ReadUint16L(temp, &iCalculatedCrc.iCrc);

	iObjectId = temp;

#ifdef STRICT_MNG_LC

	if (iObjectId !=0 )

		{

		User::Leave(KErrNotSupported); 

		}

#endif

	if (iHeader.iLength >2)

		{

		TUint8 tmp8;

		aInputStream.ReadUint8L(tmp8, &iCalculatedCrc.iCrc);

		iDoNotShow=tmp8;

		}

	if (iHeader.iLength >3)

		{

		TUint8 tmp8;

		aInputStream.ReadUint8L(tmp8, &iCalculatedCrc.iCrc);

		iConcrete=tmp8;

		}

	if (iHeader.iLength >4)

		{

		aInputStream.ReadInt32L( &iXLocation, (iHeader.iLength -4)/KInt32Size, &iCalculatedCrc.iCrc );

		}

	if (iHeader.iLength ==28 && (iLeftClippingBoundary > iRightClippingBoundary 

		  || iTopClippingBoundary > iBottomClippingBoundary))

		{

		User::Leave(KErrCorrupt);

		}

	ReadAndCheckCrcL(aInputStream);

	}

TMngChunk::TObjectFactoryFuncL TDefiChunk::MngObjectFactoryFunc() const

	{

	return CMngImageDefinition::NewL;

	}

void TTermChunk::ReadL(MInputStream& aInputStream)

	{

	if (iHeader.iLength !=1 && iHeader.iLength != 10)

		{

		User::Leave(KErrCorrupt);

		}

	TUint8 tmp8;

	aInputStream.ReadUint8L(tmp8, &iCalculatedCrc.iCrc);

	iTerminationAction=TMngTerminationAction( tmp8 );

	if (iHeader.iLength >1)

		{

		aInputStream.ReadUint8L(tmp8, &iCalculatedCrc.iCrc);

		iPostIterationAction = TMngTerminationAction( tmp8 );

		if (iTerminationAction != EMngRepeatImmidiately)

			{

#ifdef WRONG_TERM_HACK

			iPostIterationAction = iTerminationAction;

#else

			User::Leave(KErrCorrupt);

#endif

			}

		aInputStream.ReadInt32L(&iDelay, 2, &iCalculatedCrc.iCrc );

		iIterationMax+= (iIterationMax == 0);

		if (iIterationMax < 1)

			{

			User::Leave(KErrCorrupt);

			}

		}

	else

		{

		iIterationMax		= 1;

		iPostIterationAction= iTerminationAction;

		}

	if (iTerminationAction > EMngRepeatImmidiately || iPostIterationAction > EMngShowFirstFrmAfterTerm 

		 || iDelay < 0 || iIterationMax < 0)

		{

		User::Leave(KErrCorrupt);

		}

	ReadAndCheckCrcL(aInputStream);

	}

void TBackChunk::ReadL(MInputStream& aInputStream)

	{

#ifdef STRICT_MNG_LC

	if (iHeader.iLength == 9 || iHeader.iLength == 10) // we support LC profile only

		{

		User::Leave(KErrNotSupported);

		}

	if (iHeader.iLength != 6 && iHeader.iLength != 7) 

		{

		User::Leave(KErrCorrupt);

		}

#else

	if (iHeader.iLength < 6 || iHeader.iLength == 8 || iHeader.iLength > 10) 

		{

		User::Leave(KErrCorrupt);

		}

#endif

	aInputStream.ReadUint16L(&iRedBackground, 3, &iCalculatedCrc.iCrc);

	if (iHeader.iLength > 6)

		{

		TUint8 tmp8;

		aInputStream.ReadUint8L(tmp8, &iCalculatedCrc.iCrc);

		iBgMandatory = TMngBackroundMandatory(tmp8);

		}

#ifndef STRICT_MNG_LC

	if (iHeader.iLength > 7)

		{

		TUint8 temp[3];

		aInputStream.ReadUint8L(temp, iHeader.iLength - 7, &iCalculatedCrc.iCrc);

		}

#endif

	if (iBgMandatory > EMngTermBgColorAndImgMandatory)

		{

		User::Leave(KErrCorrupt);

		}

	ReadAndCheckCrcL(aInputStream);

	}

TMngChunk::TObjectFactoryFuncL TBackChunk::MngObjectFactoryFunc() const

	{

	return CMngBackground::NewL;

	}

void TMagnChunk::ReadL(MInputStream& aInputStream)

	{

#ifdef WRONG_MAGN_HACK

	TBool WrongLen= ((iHeader.iLength & 1) == 0 && iHeader.iLength > 4 && iHeader.iLength != 18 );

	if (iHeader.iLength > 20)

		{

		User::Leave(KErrCorrupt);

		}

#else

	if (iHeader.iLength > 18)

		{

		User::Leave(KErrCorrupt);

		}

#endif

	TInt DataLeft = iHeader.iLength;

	TUint8 temp8;

	if (DataLeft)

		{

		aInputStream.ReadUint16L(&iFirstMagnifiedObjId, 1, &iCalculatedCrc.iCrc);

		DataLeft -=sizeof(iFirstMagnifiedObjId);

		}

	if (DataLeft)

		{

		aInputStream.ReadUint16L(&iLastMagnifiedObjId, 1, &iCalculatedCrc.iCrc);

		DataLeft -=sizeof(iLastMagnifiedObjId);

		}

	else

		iLastMagnifiedObjId = iFirstMagnifiedObjId;

#ifdef STRICT_MNG_LC

	if (iLastMagnifiedObjId | iFirstMagnifiedObjId) // it is not supported in the MNG-LC

		{

		User::Leave(KErrNotSupported);

		}

#endif

	if (DataLeft)

		{

		aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc );

		--DataLeft;

#ifdef WRONG_MAGN_HACK

		if (WrongLen) 

			{

			aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc );

			--DataLeft;

			}

#endif

		iXMagnMethod = TMngMagnificationMethod( temp8 );

		}

	if (DataLeft && 0 != iXMagnMethod)

		{

		aInputStream.ReadUint16L(&iXMagnFactor, 1, &iCalculatedCrc.iCrc );

		DataLeft -=sizeof(iXMagnFactor);

		if (iXMagnFactor <= 0)

			{

			User::Leave(KErrCorrupt);

			}

		}

 	iRightXMagnFactor = iLeftXMagnFactor = iYMagnFactor = iXMagnFactor;

	if (DataLeft)

		{

		TInt ToRead=Min(TInt(DataLeft/sizeof(iYMagnFactor)), 3);

		aInputStream.ReadUint16L(&iYMagnFactor, ToRead , &iCalculatedCrc.iCrc );

		DataLeft -= ToRead*sizeof(iYMagnFactor);

		if (!(iYMagnFactor && iLeftXMagnFactor && iRightXMagnFactor))

			{

			User::Leave(KErrCorrupt);

			}

		}

	if (DataLeft)

		{

		aInputStream.ReadUint16L(&iTopYMagnFactor, 1, &iCalculatedCrc.iCrc );

		DataLeft -=sizeof(iTopYMagnFactor);

		if (iTopYMagnFactor <= 0)

			{

			User::Leave(KErrCorrupt);

			}

		}

	else

		{

		iTopYMagnFactor = iYMagnFactor;

		}

	if (DataLeft)

		{

		aInputStream.ReadUint16L(&iBottomYMagnFactor, 1, &iCalculatedCrc.iCrc );

		DataLeft -=sizeof(iBottomYMagnFactor);

		if (iBottomYMagnFactor <= 0)

			{

			User::Leave(KErrCorrupt);

			}

		}

	else

		iBottomYMagnFactor = iYMagnFactor;

	if (DataLeft)

		{

		aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc );

#ifdef WRONG_MAGN_HACK

		if (WrongLen) 

			{

			aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc );

			--DataLeft;

			}

#endif

		iYMagnMethod = TMngMagnificationMethod( temp8 );

		}

	else

		{

		iYMagnMethod = iXMagnMethod;

		}

	if (0 == iYMagnMethod)

		{

		iTopYMagnFactor = 0;

		}

	if (iXMagnMethod > EMngMagnLinearAlphaClosestColor || iYMagnMethod > EMngMagnLinearAlphaClosestColor)

		{

		User::Leave(KErrCorrupt);

		}

	ReadAndCheckCrcL(aInputStream);

	}

TMngChunk::TObjectFactoryFuncL TMagnChunk::MngObjectFactoryFunc() const

	{

	return CMngMagnDefinition::NewL;

	}

void TFramChunk::ReadL(MInputStream& aInputStream)

	{

	TInt DataLeft=iHeader.iLength;

	TUint8 temp8;

	if ( DataLeft != 0)

		{

		aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc);

		iFramingMode = TMngFramingMode( temp8 );

		--DataLeft;

		}

	if (DataLeft > 0)

		{

		TMngObjectName frameName;		// read and ignore the frame name

		ReadNameL(aInputStream, frameName, 

					DataLeft>frameName.MaxLength()? frameName.MaxLength(): DataLeft );

		DataLeft -= (frameName.Length() +1 ); // zero byte also

		}

	if ( DataLeft > 0)

		{

		aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc);

		iChangeInterFrmDelay=TMngFramChangeNextFrameOption( temp8 );

		--DataLeft;

		}

	if ( DataLeft > 0)

		{

		aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc);

		iChangeTimeoutAndTerm=TMngFramChangeTimeoutAndTermination( temp8 );	

		--DataLeft;

		}

	if ( DataLeft > 0)

		{

		aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc);

		iChangeClippingBoundaries=TMngFramChangeNextFrameOption( temp8 );

		--DataLeft;

		}

	if ( DataLeft > 0)

		{

		aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc);

		iChangeSyncIdList=TMngFramChangeNextFrameOption( temp8 );	

		--DataLeft;

		}

	if (iChangeInterFrmDelay)

		{

		DataLeft -=KInt32Size;

		if ( DataLeft < 0 )

			{

			User::Leave(KErrCorrupt);

			}

		aInputStream.ReadInt32L(iInterframeDelay, &iCalculatedCrc.iCrc );

		}

	if (iChangeTimeoutAndTerm)

		{

		DataLeft -=KInt32Size;

		if ( DataLeft < 0 )

			{

			User::Leave(KErrCorrupt);

			}

		aInputStream.ReadInt32L(iDelay, &iCalculatedCrc.iCrc);

		}

	if (iChangeClippingBoundaries)

		{

		DataLeft -=(KInt32Size*4 + 1);

		if ( DataLeft < 0 )

			{

			User::Leave(KErrCorrupt);

			}	

		aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc);

		iAddLayerClipping = TBool(temp8);

		aInputStream.ReadInt32L(&iLeftLayerClippingB, 4, &iCalculatedCrc.iCrc);

		}

// Proper reading of sync_id_list will be needed for full MNG implementation. We don't need it for MNG-LC

	if (iChangeSyncIdList && DataLeft>0)

		{

		aInputStream.ReadInt32L(&iFirstSyncId, 1, &iCalculatedCrc.iCrc);

		for (DataLeft-=4; DataLeft>0 ; --DataLeft)

			{

			TInt32 Dummy;

			aInputStream.ReadInt32L(&Dummy, 1, &iCalculatedCrc.iCrc);

			}

		}

	if ( DataLeft < 0

		 ||	iFramingMode > EMngFramBgLayerFor1stFgLayer || iChangeInterFrmDelay > EMngFramChangeAndResetDefault 

		 || iChangeTimeoutAndTerm > EMngFramExtSignalAndResetDef || iChangeClippingBoundaries > EMngFramChangeAndResetDefault

		 || iDelay < 0  || iInterframeDelay < 0

		 || (!iAddLayerClipping && (iLeftLayerClippingB > iRightLayerClippingB || iTopLayerClippingB > iBottomLayerClippingB)))

		{

		User::Leave(KErrCorrupt);

		}

	ReadAndCheckCrcL(aInputStream);

	}

TFramChunk::TObjectFactoryFuncL TFramChunk::MngObjectFactoryFunc() const

	{

	return CMngKeyFrame::NewL;

	}

void TLoopChunk::ReadL(MInputStream& aInputStream)

	{

	TInt DataLeft=iHeader.iLength;

	TUint8 temp8;

	if (DataLeft < 5)

		{

		User::Leave(KErrCorrupt);

		}

	aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc);

	iNestLevel = temp8;

	aInputStream.ReadInt32L(iIterationCount, &iCalculatedCrc.iCrc);

	DataLeft -=5;

	if ( DataLeft > 0)

		{

		aInputStream.ReadUint8L(temp8, &iCalculatedCrc.iCrc);

		iTerminationCondition = temp8;

		--DataLeft;

		}

// now ignore iteration_min, max and all the signals

	TInt32 Temp32;

	for (;DataLeft>0; DataLeft-=sizeof(Temp32))

		{

		aInputStream.ReadInt32L(Temp32, &iCalculatedCrc.iCrc);

		}

	if (iIterationCount < 0 )

		{

		User::Leave(KErrCorrupt);

		}

	ReadAndCheckCrcL(aInputStream);	

	}

TMngChunk::TObjectFactoryFuncL TLoopChunk::MngObjectFactoryFunc() const

	{

	return CMngLoopEntry::NewL;

	}

void TEndlChunk::ReadL(MInputStream& aInputStream)

	{

	if (1 != iHeader.iLength)

		{

		User::Leave(KErrCorrupt);

		}