diff -r 000000000000 -r 40261b775718 mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayTestData.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayTestData.h Tue Feb 02 01:56:55 2010 +0200 @@ -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 (&KTestYuvMatrix1), const_cast (&KTestYuvMatrix2), 10, 20}; +const TYuvFormat KTestYuvFormat2 = {EYuvRange1, EYuv420Chroma2, EYuvDataInterleavedLE, const_cast (&KTestYuvMatrix2), const_cast (&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__