// TestStepImageFrame.cpp

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

//

#include "TestStepImageFrame.h"

#include <imageframe.h>

#include <imageframeformats.hrh>

#include "jpgimageframeprocessor.h"

#include "JpegConsts.h"

#include <e32def.h>

#include <imageframeconst.hrh>

_LIT(KGlobalChunkName, "TestRChunkICLA");

const TInt KMaxBlocks 		  = 6;

const TInt KImageSizeInBytes  = 1024;

const TInt KUniformValue1     = 128;

const TInt KUniformValue2     = 0;

const TInt KRChunkDataOffset  = 10;

const TInt KRChunkRestrictionFlags = 0;

const TInt KMultiFrameNumber  = 2;

enum TFormatIndex

	{

	EUnknownFormat,

	EYCbCrMono,

	EYCbCr422Int,

	EYCbCr420Pla,

	EYCbCr420PlaRev

	};

enum TSizeIndex

	{

	EUnknownSize,

	EYCbCrMonoSize,

	EYCbCr422IntSize,

	EYCbCr420PlaSize

	};

const TInt KExpectedValuesIndx[][KMaxBlocks] = { 

									{0,-1,-1,-1,-1,-1},

									{0,1,2,3,-1,-1}, {0,0,2,3,-1,-1},

									{0,1,2,3,4,5}, {0,0,2,2,4,5}, {0,1,0,1,4,5}, {0,0,0,0,4,5}, {}};

const TInt KFrameSizeData[][2] = { {16,16}, {32,32}, {64,128},{640,480},{4,4}};

const TInt KFrameTestSizeData[][2] = {{32,32},{13,14}, {18,12},{18,18},{640,480},{4,4}};

const TInt KExpectedBlocksValuesIndx[][4] = { {-1}, {0,0,0,0}, {1,2,1,2},{3,4,5,6},{640,480},{4,4}};

const TUid KFrameFormatDefaults[] = 

	{ 

	{0},

	{KFormatYUVMonochromeUidValue},

	{KFormatYUV422InterleavedUidValue},

	{KFormatYUV420PlanarUidValue},

	{KFormatYUV420PlanarReversedUidValue}

	};

const TUid KFormatLists[][3] = 

	{ 

	  {{KFormatYUVMonochromeUidValue},{KColourSpaceYCbCrUidValue},{KSamplingMonochromeUidValue}},

	  {{KFormatYUV422InterleavedUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor422UidValue}},

	  {{KFormatYUV422InterleavedReversedUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor422UidValue}},

	  {{KFormatYYUV422InterleavedUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor422UidValue}},

	  {{KFormatYUV422PlanarUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor422UidValue}},

	  {{KFormatYUV420PlanarUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor420UidValue}},

	  {{KFormatYUV420PlanarReversedUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor420UidValue}},

	  {{KFormatYUV420SemiPlanarUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor420UidValue}},

	  {{KFormatYUV420InterleavedUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor420UidValue}},

	  {{KFormat16bitRGB444InterleavedUidValue},{KColourSpaceRGBUidValue},{KSamplingColor444UidValue}},

	  {{KFormat16BitRGB565InterleavedUidValue},{KColourSpaceRGBUidValue},{KSamplingColor444UidValue}},

	  {{KFormat32BitRGB888InterleavedUidValue},{KColourSpaceRGBUidValue},{KSamplingColor444UidValue}},

	  {{KFormatYUV444InterleavedUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor444UidValue}},

	  {{KFormatYUV444PlanarUidValue},{KColourSpaceYCbCrUidValue},{KSamplingColor444UidValue}},

	  {{0},{0},{0}}	

	};

const TInt KTestClipValues [][2] = {{0,0}, {255,255}, {10, 10}, {-1, 0}, {256, 255}, {128, 128}, {0x7FFF, 0xFF}, {-10, 0}};

//

// Various helper utility methods

//

// Method checking whether two formats are equal				

TBool RImageFrameUtil::FormatsEqual(const TFrameFormat& aFormat1, const TFrameFormat& aFormat2)

	{

	if ((aFormat1.FormatCode() == aFormat2.FormatCode()) &&

	    (aFormat1.ColourSpace() == aFormat2.ColourSpace()) )

		{

		return ETrue;

		}

	else 

		{

		return EFalse;

		}

	}

// Method checking whether two layouts are equal

TBool RImageFrameUtil::LayoutsEqual(const TFrameLayout& aLayout1, const TFrameLayout& aLayout2)

	{

	if ( aLayout1.Planes() != aLayout2.Planes())

		{

		return EFalse;

		}

	else

		{

		for (TInt plane = 0; plane < aLayout1.Planes(); plane++)

			{

		    if ((aLayout1.Start(plane) != aLayout2.Start(plane)) ||

			    (aLayout1.Length(plane) != aLayout2.Length(plane)) ||

			    (aLayout1.CurrentLength(plane) != aLayout2.CurrentLength(plane)) ||

			    (aLayout1.ScanLength(plane)  != aLayout2.ScanLength(plane)))

				{

				return EFalse;

				}

			}

		return ETrue;

		}

	}

// Method setting a buffer of specified size to a uniform value, either starting from start to end (forward) 

// or from end to front (backward) 

TBool RImageFrameUtil::CheckUniformAssignment(CImageFrame& aFrame, TInt aValue, 

											  TInt aBufferSize, TBool aForward)

	{

	TInt i = 0;

	TBool sucess = ETrue;

	const CImageFrame* frame1 = &aFrame;

	CImageFrame* frame = &aFrame;

	if (aForward)	

		{

		// access forward

		for (i = 0; i < aBufferSize; i++ )

			{

			frame->Data()[i] = aValue;

			if (frame1->Data()[i] != aValue)

				{

				sucess = EFail;

				break;

				}

			}

		}

	else 

		{

		// access backward

		for (i = aBufferSize-1; i >= 0; i-- )

			{

			frame->Data()[i] = aValue;

			if (frame1->Data()[i] != aValue)

				{

				sucess = EFail;

				break;

				}

			}

		}

	return sucess;

	}

// Initialises the value of a Data unit to a specific value.  	

void RImageFrameUtil::SetBlockToUniformValue(TDataUnit& aDataUnit, TInt aValue)

	{

	for (TInt i = 0; i < KJpgDCTBlockSize; i++)

		{

		aDataUnit.iCoeff[i] = aValue;

		}	

	}

// compares the values of two data units for the same index 

TBool RImageFrameUtil::CompareBlockValues(TDataUnit& aDataUnit1, 

										 TDataUnit& aDataUnit2)

	{

	TBool result = ETrue;

	for (TInt i=0; i < KJpgDCTBlockSize; i++)

		{

		if (aDataUnit1.iCoeff[i] != aDataUnit2.iCoeff[i])

			{

			result = EFalse;

			break;

			}

		}

	return result;	

	}

// assignes specific values to a array of pointers to TDataUnit

void RImageFrameUtil::InitPointerValuesL(TDataUnit* aDataUnit, RArray<const TDataUnit*> &aDataUnitPtr, TInt aBlocks)

	{

	aDataUnitPtr.Reset();

	for (TInt i=0; i < aBlocks; i++)

    	{

    	aDataUnitPtr.AppendL(&aDataUnit[i]);

    	}

	}

TInt RImageFrameUtil::LayoutPlanes(const TFrameFormat& aFormat)

	{

	TInt32 code = aFormat.FormatCode().iUid;

	switch (code)

		{

		case KFormatYUVMonochromeUidValue:

		case KFormatYUV422InterleavedUidValue:

			{

			return 1;

			}

		case KFormatYUV420PlanarUidValue:

		case KFormatYUV420PlanarReversedUidValue:

			{

			return 3;	

			}		

		default: 

			{

			return -1;	

			}		

		}

	}

// method used to initialise a layout aon the basis of format code.

// these are recommended example settings and used for demonstration only 

void RImageFrameUtil::InitLayoutValues(TFrameLayout& aLayout,TFrameFormat& aFormat, TSize& aSize, TInt& aRecommendedSize)

	{

    TInt bufferSize; 

	switch (aFormat.FormatCode().iUid)

		{

		case KFormatYUVMonochromeUidValue:

			{

			bufferSize = aSize.iWidth * aSize.iHeight;

			aLayout.SetStart(0,0);

			aLayout.SetLength(0, bufferSize);

			aLayout.SetCurrentLength(0, bufferSize);

			aLayout.SetScanLength(0,aSize.iWidth);

			aRecommendedSize = bufferSize;

			break;

			}

		case KFormatYUV422InterleavedUidValue:

			{

			if (aSize.iWidth % 4) 

				{

				aSize.iWidth = ((aSize.iWidth >> 2) + 1) << 2;

				}

			bufferSize = aSize.iWidth * aSize.iHeight * 2;

			aLayout.SetStart(0,0);

			aLayout.SetLength(0, bufferSize);

			aLayout.SetCurrentLength(0, bufferSize);

			aLayout.SetScanLength(0, aSize.iWidth * 2);

			aRecommendedSize = bufferSize;

			break;

			}

		case KFormatYUV420PlanarUidValue:

		case KFormatYUV420PlanarReversedUidValue:

			{

			bufferSize = aSize.iWidth * aSize.iHeight*3/2;

			TInt bufferSizeY = aSize.iWidth * aSize.iHeight;

			TInt bufferSizeUV = aSize.iWidth * aSize.iHeight/4;

			aLayout.SetStart(0,0);

			aLayout.SetStart(1,bufferSizeY);

			aLayout.SetStart(2,bufferSizeY+bufferSizeUV);

			aLayout.SetLength(0, bufferSizeY);

			aLayout.SetLength(1, bufferSizeUV);

			aLayout.SetLength(2, bufferSizeUV);

			aLayout.SetCurrentLength(0, bufferSizeY);

			aLayout.SetCurrentLength(1, bufferSizeUV);

			aLayout.SetCurrentLength(2, bufferSizeUV);

			aLayout.SetScanLength(0, aSize.iWidth);

			aLayout.SetScanLength(1, aSize.iWidth/2);

			aLayout.SetScanLength(2, aSize.iWidth/2);

			aRecommendedSize = bufferSize;

			break;

			}		

		default: 

			{

			}

		}

	}

//

// Base class - embeds the alloc functionaliity test as well

//	

RImageFrameTest::RImageFrameTest(TBool aAllocTest): iAllocTest(aAllocTest)

	{

	}

TVerdict RImageFrameTest::ProbeAllocTestsL()

	{

	// see if alloc fail stuff is enabled - ask if next alloc test will fail

	__UHEAP_SETFAIL(RHeap::EFailNext, 1);

	TAny *testAlloc = User::Alloc(1); 

	TBool workingOk = (testAlloc == NULL);

	User::Free(testAlloc);

	__UHEAP_SETFAIL(RHeap::ENone, 0);

	if (!workingOk)

		{

		ERR_PRINTF1(_L("RImageFrameTest::ProbeAllocTestsL Alloc Testing does not work on this build"));

		return EInconclusive;

		}

	return EPass;	

	}

// Make sure that alloc tests are run only in debug mode	

TVerdict RImageFrameTest::DoTestStepL()

	{

	TVerdict verdict = EFail;

	if (iAllocTest)

		{

		TInt failCount = 1;

		TBool completed = EFalse;

		TBool badResult = EFalse; 

		TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging

		TInt err = KErrNone;

		INFO_PRINTF2(_L("RImageFrameTest::DoTestStepL Alloc test %S starts"), &iTestStepName);

		// first make sure the alloc does not fail.

		TRAP(err, verdict = ProbeAllocTestsL());

		if (verdict != EPass)

			{

			INFO_PRINTF2(_L("RImageFrameTest::DoTestStepL ProbeAllocTestsL returned %d error"), verdict);

			}

	    if (verdict == EPass)

	    	{

	    	for (;;)

				{

				__UHEAP_SETFAIL(RHeap::EFailNext, failCount);

				__MM_HEAP_MARK;

				TRAP(err, verdict = DoTestL());

				completed = EFalse;

				if (err == KErrNone)

					{

					TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

					if (testAlloc == NULL)

						{

						reachedEnd = ETrue;

						failCount -= 1;

						}

					else

						{

						User::Free(testAlloc);			

						}

					// see if valid result and break if wrong - might be premature result

					if (verdict != EPass)

						{

						badResult = ETrue;

						}

					completed = reachedEnd || badResult;

					}

				else if (err != KErrNoMemory) // bad error code

					{

					badResult = ETrue;

					completed = ETrue;

					}

				__MM_HEAP_MARKEND;

				// reset the heap

				__UHEAP_SETFAIL(RHeap::ENone, 0);

				if (err != KErrNoMemory) 

					{

					ERR_PRINTF2(_L("RImageFrameTest::DoTestStepL Alloc Testing err %d"), err);

					User::Leave(err);

					}

				if (completed)

					{

					break; // exit loop

					}

				failCount += 1;

				}

			failCount -= 1; // Failcount of 1 equates to 0 successful allocs, etc.

			if (badResult)

				{

				verdict = EFail;

				}

	    	}

		}

    else

    	{

    	// just do the vanila tests; no alloc tests

    	verdict = DoTestL();

    	}	

    return verdict;

	}

TVerdict RImageFrameTest::DoTestL()

	{

	ERR_PRINTF1(_L("RImageFrameTest::DoTestL This function should be everridden"));

	User::Leave(KErrAbort);

	return EFail;

	}

void RImageFrameTest::InitLayoutValues(TFrameLayout& aLayout,TFrameFormat& aFormat, TSize& aSize, TInt& aRecommendedSize)

	{

	RImageFrameUtil::InitLayoutValues(aLayout, aFormat, aSize, aRecommendedSize);

	}

TInt RImageFrameTest::LayoutPlanes(const TFrameFormat& aFormat)

	{

	return RImageFrameUtil::LayoutPlanes(aFormat);

	}

//

// RImageFrameDecDesc - testing creating and acessing for reading and writing a CImageFrame

//

RImageFrameDecDesc* RImageFrameDecDesc::NewL(TBool aAllocTest)

	{

	RImageFrameDecDesc* self = new (ELeave) RImageFrameDecDesc(aAllocTest);

	return self;	

	}

RImageFrameDecDesc::RImageFrameDecDesc(TBool aAllocTest):RImageFrameTest(aAllocTest)

	{

	if (!iAllocTest)

		{

		iTestStepName = _L("MM-ICL-IMGFRM-U-0001-HP");

		}

	else

		{

		iTestStepName = _L("MM-ICL-IMGFRM-U-0101-HP");

		}

	}

TVerdict RImageFrameDecDesc::DoTestL()

	{

	TVerdict result = EPass;

	__MM_HEAP_MARK;	

	// create a desc for the data

	HBufC8* buffer = HBufC8::NewMaxL(KImageSizeInBytes);

	CleanupStack::PushL(buffer);

	// create a new frame 

	TPtr8 ptr = buffer->Des();

  	INFO_PRINTF4(_L("Test %S size %d max size %d"), &iTestStepName, ptr.Length(), ptr.MaxLength());

	CImageFrame* frame = CImageFrame::NewL(ptr, ptr.MaxLength());

	CleanupStack::PushL(frame);

	// verify frame type 

	if (frame->IsChunk())

		{

		INFO_PRINTF2(_L("Test %S The frame type is incorrect - expected descriptor"), &iTestStepName);	

		result = EFail;

		}

	else

		{

		INFO_PRINTF2(_L("Test %S The frame type is correct - descriptor"), &iTestStepName);		

		}

	// set the content of the frame to uniform value 1 

	// verify all cells have the same value

	// start to end

	TBool outcome = ETrue;

	outcome = RImageFrameUtil::CheckUniformAssignment(*frame, KUniformValue1, KImageSizeInBytes, ETrue);

    if (!outcome)

    	{

    	INFO_PRINTF2(_L("Test %S Uniform forward assignment failed"), &iTestStepName);	

    	result = EFail;

    	}

	// set the content of the frame to uniform value 2 

	// verify all cells have the same value

	// end to front

	outcome = RImageFrameUtil::CheckUniformAssignment(*frame, KUniformValue2, KImageSizeInBytes, EFalse);

    if (!outcome)

    	{

    	INFO_PRINTF2(_L("Test %S Uniform backward assignment failed"), &iTestStepName);

    	result = EFail;

    	}

	// release all

	CleanupStack::PopAndDestroy(2,buffer);

	__MM_HEAP_MARKEND;

	return result;

	}

//

// RImageFrameDecChunk - testing creating and acessing for reading and writing a CImageFrame

//	

RImageFrameDecChunk* RImageFrameDecChunk::NewL(TBool aAllocTest)

	{

	RImageFrameDecChunk* self = new (ELeave) RImageFrameDecChunk(aAllocTest);

	return self;	

	}

RImageFrameDecChunk::RImageFrameDecChunk(TBool aAllocTest):RImageFrameTest(aAllocTest)

	{

	if (!iAllocTest)

		{

		iTestStepName = _L("MM-ICL-IMGFRM-U-0002-HP");

		}

	else

		{

		iTestStepName = _L("MM-ICL-IMGFRM-U-0102-HP");