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

 // Header file: DevVideoPlay test data.

 // 

 //

 /**

  @file TestDevVideoPlayTestData.h

 */

 #ifndef __TESTDEVVIDEOPLAYTESTDATA_H__

 #define __TESTDEVVIDEOPLAYTESTDATA_H__

 #include "TSU_MMF_DevVideo.h"

 // mime types

 _LIT8(KTestMimeType1, "video/testvideo");

 // optional data

 _LIT8(KTestOptional1, "blah blah blah blah blah");

 // test uncompressed video formats

 const TUncompressedVideoFormat KTestVidFormat1 = {ERgbRawData};

 const TUncompressedVideoFormat KTestVidFormat2 = {ERgbFbsBitmap};

 const TUncompressedVideoFormat KTestVidFormat3 = {EYuvRawData};

 // test unit and encapsulation types

 const TVideoDataUnitType KTestUnitType1				= EDuCodedPicture;

 const TVideoDataUnitEncapsulation KTestEncapType1	= EDuElementaryStream;

 // test compressed video format utility function

 static inline CCompressedVideoFormat* GetTestCVFormatL( const TDesC8& aMimeType )

 	{

 	CCompressedVideoFormat* temp = CCompressedVideoFormat::NewL( aMimeType, KTestOptional1 );

  	return temp;

 	}

 // test pre-process types

 const TUint32 KTestProcessType1 = EPpInputCrop | EPpMirror | EPpRotate;

 const TUint32 KTestProcessType2 = EPpScale | EPpOutputCrop | EPpOutputPad;

 // input crop rectangles

 const TInt KTestInputCropRectA = 0;

 const TInt KTestInputCropRectB = 50;

 const TInt KTestInputCropRectC = 100;

 const TInt KTestInputCropRectD = 150;

 // KTestInputCropRect1 = A, B, C, D;

 // KTestInputCropRect2 = D, C, B, A;

 // yuv to rgb options

 const TYuvToRgbOptions KTestYuvToRgb1 = {50, 50, 50, 0.5, EDitherNone};

 const TYuvToRgbOptions KTestYuvToRgb2 = {100, 100, 100, 1.0, EDitherErrorDiffusion};

 static inline TBool CompareYuvRgbOptions(const TYuvToRgbOptions& a, const TYuvToRgbOptions& b)

 	{

 	if ( (a.iLightness == b.iLightness) && (a.iSaturation == b.iSaturation) &&		 

 		 (a.iContrast == b.iContrast) && (a.iGamma == b.iGamma) &&

 		 (a.iDitherType == b.iDitherType) )

 		 return ETrue;

 	else return EFalse;

 	}

 // conversion matrices

 const TYuvConversionMatrix KTestYuvMatrix1 = {{1, 2, 3}, {4, 5, 6, 7, 8, 9, 10, 11, 12}, {13, 14, 15}};

 const TYuvConversionMatrix KTestYuvMatrix2 = {{-1, -2, -3}, {-4, -5, -6, -7, -8, -9, -10, -11, -12}, {-13, -14, -15}};

 static inline TBool CompareYuvMatrices(const TYuvConversionMatrix& a, const TYuvConversionMatrix& b)

 	{

 	TBool same = ETrue;

 	TInt x = 0;

 	for (x = 0; x < 3; x++)

 		{

 		if ( (a.iPostOffset[x] != b.iPostOffset[x]) ||

 			 (a.iPreOffset[x] != b.iPreOffset[x]) )

 			{

 			same = EFalse;

 			}

 		}

 	for (x = 0; x < 9; x++)

 		{

 		if (a.iMatrix[x] != b.iMatrix[x]) 

 			{

 			same = EFalse;

 			}

 		}

 	return same;

 	}

 // yuv formats

 const TYuvFormat KTestYuvFormat1 = {EYuvRange0, EYuv420Chroma1, EYuvDataPlanar, const_cast <TYuvConversionMatrix*> (&KTestYuvMatrix1), const_cast <TYuvConversionMatrix*> (&KTestYuvMatrix2), 10, 20};

 const TYuvFormat KTestYuvFormat2 = {EYuvRange1, EYuv420Chroma2, EYuvDataInterleavedLE, const_cast <TYuvConversionMatrix*> (&KTestYuvMatrix2), const_cast <TYuvConversionMatrix*> (&KTestYuvMatrix1), 5, 10};

 static inline TBool CompareYuvFormats(const TYuvFormat& a, const TYuvFormat& b)

 	{

 	if ( (a.iCoefficients == b.iCoefficients) && 

 		 (a.iPattern == b.iPattern) &&		 

 		 (a.iDataLayout == b.iDataLayout) && 

 		 (CompareYuvMatrices(*a.iYuv2RgbMatrix, *b.iYuv2RgbMatrix)) &&

 		 (CompareYuvMatrices(*a.iRgb2YuvMatrix, *b.iRgb2YuvMatrix)) &&

 		 (a.iAspectRatioNum == b.iAspectRatioNum) &&

 		 (a.iAspectRatioDenom == b.iAspectRatioDenom) )

 		 return ETrue;

 	else return EFalse;

 	}

 // rgb formats

 const TRgbFormat KTestRgbFormat1 = ERgb16bit444;

 const TRgbFormat KTestRgbFormat2 = EFbsBitmapColor16M;

 // rotation types

 const TRotationType KTestRotate1 = ERotate90Clockwise;

 const TRotationType KTestRotate2 = ERotate90Anticlockwise;

 // test scale size

 const TInt KTestScaleX = 100; 

 const TInt KTestScaleY = 50;

 // output crop rectangles

 const TInt KTestOutputCropRectA = 0;

 const TInt KTestOutputCropRectB = 50;

 const TInt KTestOutputCropRectC = 256;

 const TInt KTestOutputCropRectD = 350;

 // KTestOutputCropRect1 = A, B, C, D;

 // KTestOutputCropRect2 = D, C, B, A;

 // post-processor options

 _LIT8(KTestPostProcOptions1, "abcdefghijklmno");

 _LIT8(KTestPostProcOptions2, "123456-7-654321");

 // buffer options creation utility function

 static inline CMMFDevVideoPlay::TBufferOptions GetTestBufferOptions( void )

 	{

 	CMMFDevVideoPlay::TBufferOptions buffOptions;

 	buffOptions.iPreDecodeBufferSize = 10;

 	buffOptions.iMaxPostDecodeBufferSize = 20;

 	buffOptions.iPreDecoderBufferPeriod = 30;

 	buffOptions.iPostDecoderBufferPeriod = 40;

 	buffOptions.iMaxInputBufferSize = 50;

 	buffOptions.iMinNumInputBuffers = 60;

 	return buffOptions;

 	}

 // buffer options comparison utility function 

 static inline TBool CompareBufferOptions(const CMMFDevVideoPlay::TBufferOptions& a, const CMMFDevVideoPlay::TBufferOptions& b)

 	{

 	if ( (a.iPreDecodeBufferSize == b.iPreDecodeBufferSize) && 

 		 (a.iMaxPostDecodeBufferSize == b.iMaxPostDecodeBufferSize) &&		 

 		 (a.iPreDecoderBufferPeriod == b.iPreDecoderBufferPeriod) && 

 		 (a.iPostDecoderBufferPeriod == b.iPostDecoderBufferPeriod) &&

 		 (a.iMaxInputBufferSize == b.iMaxInputBufferSize) &&

 		 (a.iMinNumInputBuffers == b.iMinNumInputBuffers) )

 		 return ETrue;

 	else return EFalse;

 	}

 // Hrd/Vbv test data

 const THrdVbvSpecification KTestHrdVbvSpec = EHrdVbv3GPP;

 _LIT8(KTestHrdVbvParams, "not exactly a package of parameters but never mind");

 // direct screen access test data

 const TInt KTestDSARectA = 0;

 const TInt KTestDSARectB = 100;

 const TInt KTestDSARectC = 200;

 const TInt KTestDSARectD = 300;

 // KTestDSARect1 = A, B, C, D;

 // KTestDSARect2 = D, C, B, A;

 // KTestDSARegion1 = {KTestDSARect1};

 // KTestDSARegion2 = {KTestDSARect2};

 // position test data

 const TInt KTestPosition = 12345;

 const TInt KTestPositionFatal = 666;

 const TInt KTestDecodePosition = 256;

 const TInt KTestPlayPosition = 512;

 // buffer bytes test data

 const TUint KTestPreDecoderBytes = 1024;

 const TUint KTestPictureBytes = 2048;

 // picture counters creation utility function

 static inline CMMFDevVideoPlay::TPictureCounters GetTestPictureCounters( void )

 	{

 	CMMFDevVideoPlay::TPictureCounters picCount;

 	picCount.iPicturesSkipped = 10;

 	picCount.iPicturesDecoded = 20;

 	picCount.iPicturesDisplayed = 30;

 	picCount.iTotalPictures = 40;

 	return picCount;

 	}

 // picture counters comparison utility function 

 static inline TBool ComparePictureCounters(const CMMFDevVideoPlay::TPictureCounters& a, const CMMFDevVideoPlay::TPictureCounters& b)

 	{

 	if ( (a.iPicturesSkipped == b.iPicturesSkipped) && 

 		 (a.iPicturesDecoded == b.iPicturesDecoded) &&		 

 		 (a.iPicturesDisplayed == b.iPicturesDisplayed) && 

 		 (a.iTotalPictures == b.iTotalPictures) )

 		 return ETrue;

 	else return EFalse;

 	}

 // bitstream counters creation utility function

 static inline CMMFDevVideoPlay::TBitstreamCounters GetTestBitstreamCounters( void )

 	{

 	CMMFDevVideoPlay::TBitstreamCounters bitCount;

 	bitCount.iLostPackets = 256;

 	bitCount.iTotalPackets = 512;

 	return bitCount;

 	}

 // bitstream counters comparison utility function 

 static inline TBool CompareBitstreamCounters(const CMMFDevVideoPlay::TBitstreamCounters& a, const CMMFDevVideoPlay::TBitstreamCounters& b)

 	{

 	if ( (a.iLostPackets == b.iLostPackets) && 

 		 (a.iTotalPackets == b.iTotalPackets) )

 		 return ETrue;

 	else return EFalse;

 	}

 // test num buffers

 const TUint KTestNumFreeBuffers = 4096;

 // complexity levels

 const TUint KTestComplexityLevel1 = 1;

 const TUint KTestComplexityLevel2 = 3;

 const TUint KTestNumComplexityLevels1 = 5;

 const TUint KTestNumComplexityLevels2 = 10;

 // complexity level info creation utility function

 static inline CMMFDevVideoPlay::TComplexityLevelInfo GetTestLevelInfo( TInt a )

 	{

 	CMMFDevVideoPlay::TComplexityLevelInfo levInfo;

 	levInfo.iOptions = CMMFDevVideoPlay::TComplexityLevelInfo::EAvgPictureRate;

 	levInfo.iAvgPictureRate = 1.5;

 	levInfo.iPictureSize.SetSize(a * 100,a * 200);

 	levInfo.iRelativeImageQuality = 0.5;

 	levInfo.iRequiredMIPS = a;

 	levInfo.iRelativeProcessTime = 0.3;

 	return levInfo;

 	}

 // complexity level info comparison utility function 

 static inline TBool CompareLevelInfos(const CMMFDevVideoPlay::TComplexityLevelInfo& a, const CMMFDevVideoPlay::TComplexityLevelInfo& b)

 	{

 	if ( (a.iOptions == b.iOptions) && 

 		 (a.iAvgPictureRate == b.iAvgPictureRate) &&

 		 (a.iPictureSize == b.iPictureSize) &&

 		 (a.iRelativeImageQuality == b.iRelativeImageQuality) &&

 		 (a.iRequiredMIPS == b.iRequiredMIPS) &&

 		 (a.iRelativeProcessTime == b.iRelativeProcessTime) )

 		 return ETrue;

 	else return EFalse;

 	}

 // picture timestamp test data

 const TInt KTestPictureTimestamp = 12345;

 // input buffer test data

 _LIT8(KTestBufferString, "Roobarb and Custard!");

 const TUint32 KTestBufferOptions = TVideoInputBuffer::EDecodingTimestamp;

 const TUint KTestBufferSize = 20;

 // decoder info

 const TUint32 KTestDecoderInfoCount = 3;

 const TText8* const KTestDecoderInfoMimeArray[KTestDecoderInfoCount] = 

 	{

 	_S8("video/bunglevideo"), 

 	_S8("video/zippyvideo"),

 	_S8("video/georgevideo")

 	};

 _LIT(KTestDecoderInfoManufacturer, "fred bloggs plc");

 _LIT(KTestDecoderInfoIdentifier, "video funkifier");

 const TInt KTestDecoderInfoMaxSizeX = 256;

 const TInt KTestDecoderInfoMaxSizeY = 512;

 _LIT8(KTestDecoderInfoCSInfo, "coded by a blind monkey");

 _LIT8(KTestDecoderInfoISInfo, "implemented by a baboon");

 const TInt KTestDecoderInfoVersionMaj = 1;

 const TInt KTestDecoderInfoVersionMin = 2;

 const TInt KTestDecoderInfoVersionBuild = 3;

 // KTestDecoderInfoVersion = Maj.Min.Build;

 // post processor info

 const TUint32 KTestPostProcInfoCount = 3;

 _LIT(KTestPostProcInfoManufacturer, "honest sid inc");

 _LIT(KTestPostProcInfoIdentifier, "video post-funkifier");

 _LIT8(KTestPostProcInfoISInfo, "implemented by a lame pigeon");

 const TInt KTestPostProcInfoVersionMaj = 1;

 const TInt KTestPostProcInfoVersionMin = 2;

 const TInt KTestPostProcInfoVersionBuild = 3;

 // KTestPostProcInfoVersion = Maj.Min.Build;

 const TUint32 KTestPostProcInfoRotations = ERotate90Clockwise | ERotate90Anticlockwise | ERotate180;

 const TYuvToRgbCapabilities KTestPostProcInfoYuvToRgbCaps = {1, 2, 3, ETrue, EFalse, ETrue, EFalse, 4};

 static inline TBool CompareYuvRgbCaps(const TYuvToRgbCapabilities& a, const TYuvToRgbCapabilities& b)

 	{

 	if ( (a.iSamplingPatterns == b.iSamplingPatterns) && (a.iCoefficients == b.iCoefficients) &&		 

 		 (a.iRgbFormats == b.iRgbFormats) && (a.iLightnessControl == b.iLightnessControl) &&

 		 (a.iSaturationControl == b.iSaturationControl) && (a.iContrastControl == b.iContrastControl) &&

 		 (a.iGammaCorrection == b.iGammaCorrection) && (a.iDitherTypes == b.iDitherTypes) )

 		 return ETrue;

 	else return EFalse;

 	}

 const TUncompressedVideoFormat KTestPostProcInfoFormatArray[KTestPostProcInfoCount] =

 	{{ERgbRawData}, {ERgbFbsBitmap}, {EYuvRawData}};

 const TUint32 KTestPostProcInfoCombsArray[KTestPostProcInfoCount] =

 	{KTestProcessType1, KTestProcessType2, EPpNoiseFilter | EPpColorEnhancement | EPpFrameStabilisation};

 const TScaleFactor KTestPostProcInfoScaleFactorsArray[KTestPostProcInfoCount] =

 	{{1, 2}, {1, 4}, {1,8}};

 static inline TBool CompareScaleFactors(const TScaleFactor& a, const TScaleFactor& b)

 	{

 	if ((a.iScaleNum == b.iScaleNum) && (a.iScaleDenom == b.iScaleDenom))

 		return ETrue;

 	else return EFalse;

 	}

 const TUncompressedVideoFormat KTestPostProcInfoNegativeFormat = {EYuvRawData};

 const TUint32 KTestPostProcInfoNegativeComb = EPpCustom;

 // video header information

 const TVideoDataUnitType KTestDataUnitType = EDuCodedPicture;

 const TVideoDataUnitEncapsulation KTestDataUnitEncap = EDuElementaryStream;

 const TVideoInputBuffer::TVideoBufferOptions KTestInputBufferOptions = TVideoInputBuffer::EPresentationTimestamp; 

 const TVideoPictureHeader::THeaderOptions KTestPictureHeaderOptions = TVideoPictureHeader::EPresentationTimestamp;

 const TInt KTestInputBufferTimestamp = 1000000;

 const TInt KTestPictureHeaderTimestamp = 2000000;

 _LIT8(KTestInputBufferData, "I'm a lumber jack and I'm OK!");

 // TPictureData

 const TInt KTestPictureDataSizeX = 57;

 const TInt KTestPictureDataSizeY = 18;

 // snapshot data

 const TInt KTestSnapshotTimestamp = 1000;

 const TPictureId KTestSnapshotId = {TPictureId::ETemporalReference, 999};

 // clock deviation

 const TUint KTestClockDeviationMS	 = 500000;		// 0.5 seconds

 const TUint KTestClockBigDeviationMS = 2000000;		// 2 seconds

 const TUint KTestClock2Seconds	  = 2000000;

 const TUint KTestClock4Seconds	  = 4000000;

 const TUint KTestClock18Seconds	  = 18000000;

 const TUint KTestClock20Seconds	  = 20000000;

 const TUint KTestClock22Seconds	  = 22000000;

 // devvideorecord specific test data

 const TInt KTestInputSize1X = 640; 

 const TInt KTestInputSize1Y = 480;

 const TInt KTestInputSize2X = 320; 

 const TInt KTestInputSize2Y = 200;

 const TInt KTestCamHandlePre = 1;

 const TInt KTestCamHandleEnc = 2;

 const TInt KTestCamHandleFatal = 666;

 const TReal KTestPictureRate = 29.97;

 // rgb data

 const TRgbRange KTestRgbRange1 = ERgbRangeFull;

 const TRgbRange KTestRgbRange2 = ERgbRange16to235;

 // output pad

 const TInt KTestPadX = 100;

 const TInt KTestPadY = 200;

 const TInt KTestPadPointX = 300;

 const TInt KTestPadPointY = 400;

 // color enhancement

 const TColorEnhancementOptions KTestColorEnhance1 = {1, 2, 3};

 const TColorEnhancementOptions KTestColorEnhance2 = {4, 5, 6};

 static inline TBool CompareColorEnhancements(const TColorEnhancementOptions& a, const TColorEnhancementOptions& b)

 	{

 	if ( (a.iLightness == b.iLightness) && 

 		 (a.iSaturation == b.iSaturation) && 

 		 (a.iContrast == b.iContrast) )

 		 return ETrue;

 	else return EFalse;

 	}

 // custom pre process options

 _LIT8(KTestCustomPreProc1, "rhubarb rhubarb rhubarb!");

 _LIT8(KTestCustomPreProc2, "custard custard custard?");

 const TReal KTestRandomAccessRate = 0.555;

 const TUint KTestNumBitrateLayers = 369;

 const TUint KTestLayer = 12;

 const TScalabilityType KTestScaleType = EScalabilityQualityFG;

 const TUint KTestMaxRefPics = 9;

 const TUint KTestMaxPicDelay = 111;

 // encoder buffer options creation utility function

 static inline TEncoderBufferOptions GetTestEncBufferOptions( void )

 	{

 	TEncoderBufferOptions buffOptions;

 	buffOptions.iMaxPreEncoderBufferPictures = 10;

 	buffOptions.iHrdVbvSpec = KTestHrdVbvSpec;

 	buffOptions.iHrdVbvParams.Set(KTestHrdVbvParams);

 	buffOptions.iMaxOutputBufferSize = 100;

 	buffOptions.iMaxCodedPictureSize = 200;

 	buffOptions.iMaxCodedSegmentSize = 300;

 	buffOptions.iMinNumOutputBuffers = 400;

 	return buffOptions;

 	}

 // encoder buffer options comparison utility function 

 static inline TBool CompareEncBufferOptions(const TEncoderBufferOptions& a, const TEncoderBufferOptions& b)

 	{

 	if ( (a.iMaxPreEncoderBufferPictures == b.iMaxPreEncoderBufferPictures) && 

 		 (a.iHrdVbvSpec == b.iHrdVbvSpec) &&		 

 		 (a.iHrdVbvParams == b.iHrdVbvParams) && 

 		 (a.iMaxOutputBufferSize == b.iMaxOutputBufferSize) &&

 		 (a.iMaxCodedPictureSize == b.iMaxCodedPictureSize) &&

 		 (a.iMaxCodedSegmentSize == b.iMaxCodedSegmentSize) &&

 		 (a.iMinNumOutputBuffers == b.iMinNumOutputBuffers) )

 		 return ETrue;

 	else return EFalse;

 	}

 _LIT8(KTestCSEncoderOptions, "there's a moose in the hoose!");

 _LIT8(KTestISEncoderOptions, "but did the moose chase the goose?");

 _LIT8(KTestISInitOutput, "I am a mole...");

 _LIT8(KTestCSInitOutput, "...and I live in a hole!");

 const TUint KTestProtectLevels = 444;

 const TUint KTestLevel = 11;

 const TUint KTestBitrate = 192;

 const TUint KTestStrength = EFecStrengthLow;

 const TInt KTestLossBurstLength = 123456;

 const TUint KTestLossRate = 8192;

 const TReal KTestErrorRate = 1.11;

 const TReal KTestStdDeviation = 2.22;

 const TUint KTestSizeBytes = 8;

 const TUint KTestSizeMacroblocks = 244;

 // encoder rate control options creation utility function

 static inline TRateControlOptions GetTestRateControlOptions( void )

 	{

 	TRateControlOptions rateOptions;

 	rateOptions.iControl = EBrControlPicture;

 	rateOptions.iBitrate = 256;

 	rateOptions.iPictureQuality = 512;

 	rateOptions.iPictureRate = 1.234;

 	rateOptions.iQualityTemporalTradeoff = 4.321;

 	rateOptions.iLatencyQualityTradeoff = 5.678;

 	return rateOptions;

 	}

 // encoder rate control options comparison utility function 

 static inline TBool CompareRateControlOptions(const TRateControlOptions& a, const TRateControlOptions& b)

 	{

 	if ( (a.iControl == b.iControl) && 

 		 (a.iBitrate == b.iBitrate) &&		 

 		 (a.iPictureQuality == b.iPictureQuality) && 

 		 (a.iPictureRate == b.iPictureRate) &&

 		 (a.iQualityTemporalTradeoff == b.iQualityTemporalTradeoff) &&

 		 (a.iLatencyQualityTradeoff == b.iLatencyQualityTradeoff) )

 		 return ETrue;

 	else return EFalse;

 	}

 // scalability

 const TUint KTestNumSteps = 56;

 const TInLayerScalabilityType KTestLayerScaleType = EInLScalabilityTemporal;

 const TUint KTestBitrateShare1 = 666;

 const TUint KTestBitrateShare2 = 777;

 const TUint KTestPictureShare1 = 888;

 const TUint KTestPictureShare2 = 999;

 const TUint KTestPointPeriod = 2;

 // settings output

 _LIT8(KTestISSettingsOutput, "seven deadly sins...");

 _LIT8(KTestCSSettingsOutput, "...seven ways to win");

 // picture timestamp

 const TInt KTestEncPictureTimestamp = 98765;

 // supplemental info

 _LIT8(KTestSuppInfo, "don't eat spaghetti with chopsticks...");

 const TInt KTestSuppTime = 6000000;

 const TInt KTestSuppTimeCancel = 666666666;

 const TInt KTestRecordPosition = 999666333;

 const TUint KTestFreeBuffers = 9;

 const TUint KTestFreeBytes = 256;

 // picture counters creation utility function

 static inline CMMFDevVideoRecord::TPictureCounters GetTestEncPictureCounters( void )

 	{

 	CMMFDevVideoRecord::TPictureCounters picCount;

 	picCount.iPicturesSkippedBufferOverflow = 10;

 	picCount.iPicturesSkippedProcPower = 20;

 	picCount.iPicturesSkippedRateControl = 30;

 	picCount.iPicturesProcessed = 40;

 	picCount.iInputPictures = 50;

 	return picCount;

 	}

 // picture counters comparison utility function 

 static inline TBool CompareEncPictureCounters(const CMMFDevVideoRecord::TPictureCounters& a, const CMMFDevVideoRecord::TPictureCounters& b)

 	{

 	if ( (a.iPicturesSkippedBufferOverflow == b.iPicturesSkippedBufferOverflow) && 

 		 (a.iPicturesSkippedProcPower == b.iPicturesSkippedProcPower) &&		 

 		 (a.iPicturesSkippedRateControl == b.iPicturesSkippedRateControl) && 

 		 (a.iPicturesProcessed == b.iPicturesProcessed) &&

 		 (a.iInputPictures == b.iInputPictures ))

 		 return ETrue;

 	else return EFalse;

 	}

 const TInt KTestEncInputPictures = 10;

 const TInt KTestFrameStableX1 = 5;

 const TInt KTestFrameStableY1 = 10;

 const TInt KTestFrameStableX2 = 300;

 const TInt KTestFrameStableY2 = 200;

 const TPictureId KTestPictureId1 = {TPictureId::ETemporalReference, 999};

 const TPictureId KTestPictureId2 = {TPictureId::ETemporalReference, 666};

 const TPictureId KTestPictureId3 = {TPictureId::ETemporalReference, 333};

 static inline TBool ComparePictureIDs(const TPictureId& a, const TPictureId&b)

 	{

 	return ((a.iIdType == b.iIdType) && (a.iId == b.iId));

 	}

 // slice loss

 const TUint KTestFirstMacroblock = 50;

 const TUint KTestNumMacroblocks = 3;

 // ref picture data

 _LIT8(KTestRefPictureInfo, "there once was an ugly duckling...");

 // start / stop / pause / resume positions

 const TInt KTestRecTimeStop	= 0;	

 const TInt KTestRecTimeStartEnc = 10;

 const TInt KTestRecTimePauseEnc = 20;

 const TInt KTestRecTimeResumeEnc = 30;

 const TInt KTestRecTimeStartPre = 40;

 const TInt KTestRecTimePausePre = 50;

 const TInt KTestRecTimeResumePre = 60;

 // command to start buffer creation

 _LIT8(KTestISEncBuffers, "get them buffers a rollin!");

 _LIT8(KTestISEncBufferData, "steam rollin along!");

 // encoder info

 const TUint32 KTestEncoderInfoCount = 3;

 const TText8* const KTestEncoderInfoMimeArray[KTestEncoderInfoCount] = 

 	{

 	_S8("video/bunglevideo"), 

 	_S8("video/zippyvideo"),

 	_S8("video/georgevideo")

 	};

 _LIT(KTestEncoderInfoManufacturer, "bodgitt plc");

 _LIT(KTestEncoderInfoIdentifier, "video bodger");

 _LIT8(KTestEncoderInfoCSInfo, "coded by a blind orangutan");

 _LIT8(KTestEncoderInfoISInfo, "implemented by an imp");

 const TInt KTestEncoderInfoVersionMaj = 11;

 const TInt KTestEncoderInfoVersionMin = 22;

 const TInt KTestEncoderInfoVersionBuild = 33;

 // KTestEncoderInfoVersion = Maj.Min.Build;

 const TInt KTestEncoderInfoMaxSizeX = 256;

 const TInt KTestEncoderInfoMaxSizeY = 512;

 const TUint KTestEncoderInfoMaxUEPLevels = 5;

 const TUint KTestEncoderInfoMaxBitrate = 963;

 const TUint KTestEncoderInfoMaxILSSteps = 555;

 const TUint32 KTestEncoderInfoPictureOptions = TVideoPicture::ESceneCut | TVideoPicture::EEffectParameters | TVideoPicture::ETimestamp;

 static inline void GetTestEncoderInfoRate(TInt aIndex, TPictureRateAndSize& aRate)

 	{

 	TPictureRateAndSize rate;

 	TSize size(aIndex * 10, aIndex * 20);

 	TReal rIndex = aIndex;

 	rate.iPictureSize = size;

 	rate.iPictureRate = rIndex / 10.0;

 	aRate = rate;

 	}

 // Pre Processor Info

 _LIT(KTestPreProcInfoManufacturer, "iced inc");

 _LIT(KTestPreProcInfoIdentifier, "video munger");

 _LIT8(KTestPreProcInfoISInfo, "implemented by a marsupial");

 const TInt KTestPreProcInfoVersionMaj = 44;

 const TInt KTestPreProcInfoVersionMin = 55;

 const TInt KTestPreProcInfoVersionBuild = 66;

 // KTestPreProcInfoVersion = Maj.Min.Build;

 const TUint32 KTestPreProcInfoRotations = KTestRotate1 | KTestRotate2;

 const TUint32 KTestPreProcInfoRgbRanges = KTestRgbRange1 | KTestRgbRange2;

 const TYuvToYuvCapabilities KTestPreProcInfoYuvToYuvCaps = {1, 2, 3, 4};

 static inline TBool CompareYuvYuvCapabilities(const TYuvToYuvCapabilities& a, const TYuvToYuvCapabilities& b)

 	{

 	return ((a.iInputSamplingPatterns == b.iInputSamplingPatterns) &&

 			(a.iInputDataLayouts == b.iInputDataLayouts) &&

 			(a.iOutputSamplingPatterns == b.iOutputSamplingPatterns) &&

 			(a.iOutputDataLayouts == b.iOutputDataLayouts) );

 	}

 const TUncompressedVideoFormat KTestPreProcInfoOutputFormatArray[KTestPostProcInfoCount] =

 	{{ERgbRawData}, {ERgbFbsBitmap}, {EYuvRawData}};

 const TUncompressedVideoFormat KTestPreProcInfoInputFormatArray[KTestPostProcInfoCount] =

 	{{ERgbFbsBitmap}, {EYuvRawData}, {ERgbRawData}};

 const TUncompressedVideoFormat KTestPreProcInfoNegativeFormat = {ERgbRawData};

 // Custom Interface UIDs

 const TUid KUidCustomInterfaceOne	= {0x101F7DD1};	//Supported by decoder

 const TUid KUidCustomInterfaceTwo	= {0x101F7DD2};	//Supported by post processor

 const TUid KUidCustomInterfaceThree = {0x101F7DD3};	//Supported by encoder

 const TUid KUidCustomInterfaceFour	= {0x101F7DD4};	//Supported by pre processor

 #endif	// __TESTDEVVIDEOPLAYTESTDATA_H__