--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayTestData.h Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,679 @@
+// 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__