1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Header file: DevVideoPlay test data.

    15 // 

    16 //

    17 

    18 /**

    19  @file TestDevVideoPlayTestData.h

    20 */

    21 

    22 #ifndef __TESTDEVVIDEOPLAYTESTDATA_H__

    23 #define __TESTDEVVIDEOPLAYTESTDATA_H__

    24 

    25 #include "TSU_MMF_DevVideo.h"

    26 

    27 

    28 // mime types

    29 _LIT8(KTestMimeType1, "video/testvideo");

    30 

    31 // optional data

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

    33 

    34 // test uncompressed video formats

    35 const TUncompressedVideoFormat KTestVidFormat1 = {ERgbRawData};

    36 const TUncompressedVideoFormat KTestVidFormat2 = {ERgbFbsBitmap};

    37 const TUncompressedVideoFormat KTestVidFormat3 = {EYuvRawData};

    38 

    39 // test unit and encapsulation types

    40 const TVideoDataUnitType KTestUnitType1				= EDuCodedPicture;

    41 const TVideoDataUnitEncapsulation KTestEncapType1	= EDuElementaryStream;

    42 

    43 // test compressed video format utility function

    44 static inline CCompressedVideoFormat* GetTestCVFormatL( const TDesC8& aMimeType )

    45 	{

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

    47  	return temp;

    48 	}

    49 

    50 // test pre-process types

    51 const TUint32 KTestProcessType1 = EPpInputCrop | EPpMirror | EPpRotate;

    52 const TUint32 KTestProcessType2 = EPpScale | EPpOutputCrop | EPpOutputPad;

    53 

    54 // input crop rectangles

    55 const TInt KTestInputCropRectA = 0;

    56 const TInt KTestInputCropRectB = 50;

    57 const TInt KTestInputCropRectC = 100;

    58 const TInt KTestInputCropRectD = 150;

    59 

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

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

    62 

    63 // yuv to rgb options

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

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

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

    67 	{

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

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

    70 		 (a.iDitherType == b.iDitherType) )

    71 		 return ETrue;

    72 	else return EFalse;

    73 	}

    74 

    75 

    76 // conversion matrices

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

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

    79 

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

    81 	{

    82 	TBool same = ETrue;

    83 	TInt x = 0;

    84 

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

    86 		{

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

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

    89 			{

    90 			same = EFalse;

    91 			}

    92 		}

    93 		

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

    95 		{

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

    97 			{

    98 			same = EFalse;

    99 			}

   100 		}

   101 		

   102 	return same;

   103 	}

   104 

   105 // yuv formats

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

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

   108 

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

   110 	{

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

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

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

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

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

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

   117 		 (a.iAspectRatioDenom == b.iAspectRatioDenom) )

   118 		 return ETrue;

   119 	else return EFalse;

   120 	}

   121 

   122 // rgb formats

   123 const TRgbFormat KTestRgbFormat1 = ERgb16bit444;

   124 const TRgbFormat KTestRgbFormat2 = EFbsBitmapColor16M;

   125 

   126 // rotation types

   127 const TRotationType KTestRotate1 = ERotate90Clockwise;

   128 const TRotationType KTestRotate2 = ERotate90Anticlockwise;

   129 

   130 // test scale size

   131 const TInt KTestScaleX = 100; 

   132 const TInt KTestScaleY = 50;

   133 

   134 // output crop rectangles

   135 const TInt KTestOutputCropRectA = 0;

   136 const TInt KTestOutputCropRectB = 50;

   137 const TInt KTestOutputCropRectC = 256;

   138 const TInt KTestOutputCropRectD = 350;

   139 

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

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

   142 

   143 // post-processor options

   144 _LIT8(KTestPostProcOptions1, "abcdefghijklmno");

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

   146 

   147 // buffer options creation utility function

   148 static inline CMMFDevVideoPlay::TBufferOptions GetTestBufferOptions( void )

   149 	{

   150 	CMMFDevVideoPlay::TBufferOptions buffOptions;

   151  	

   152 	buffOptions.iPreDecodeBufferSize = 10;

   153 	buffOptions.iMaxPostDecodeBufferSize = 20;

   154 	buffOptions.iPreDecoderBufferPeriod = 30;

   155 	buffOptions.iPostDecoderBufferPeriod = 40;

   156 	buffOptions.iMaxInputBufferSize = 50;

   157 	buffOptions.iMinNumInputBuffers = 60;

   158 

   159 	return buffOptions;

   160 	}

   161 

   162 // buffer options comparison utility function 

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

   164 	{

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

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

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

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

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

   170 		 (a.iMinNumInputBuffers == b.iMinNumInputBuffers) )

   171 		 return ETrue;

   172 	else return EFalse;

   173 	}

   174 

   175 // Hrd/Vbv test data

   176 const THrdVbvSpecification KTestHrdVbvSpec = EHrdVbv3GPP;

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

   178 

   179 // direct screen access test data

   180 const TInt KTestDSARectA = 0;

   181 const TInt KTestDSARectB = 100;

   182 const TInt KTestDSARectC = 200;

   183 const TInt KTestDSARectD = 300;

   184 

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

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

   187 

   188 // KTestDSARegion1 = {KTestDSARect1};

   189 // KTestDSARegion2 = {KTestDSARect2};

   190 

   191 // position test data

   192 const TInt KTestPosition = 12345;

   193 const TInt KTestPositionFatal = 666;

   194 const TInt KTestDecodePosition = 256;

   195 const TInt KTestPlayPosition = 512;

   196 

   197 // buffer bytes test data

   198 const TUint KTestPreDecoderBytes = 1024;

   199 const TUint KTestPictureBytes = 2048;

   200 

   201 // picture counters creation utility function

   202 static inline CMMFDevVideoPlay::TPictureCounters GetTestPictureCounters( void )

   203 	{

   204 	CMMFDevVideoPlay::TPictureCounters picCount;

   205  	

   206 	picCount.iPicturesSkipped = 10;

   207 	picCount.iPicturesDecoded = 20;

   208 	picCount.iPicturesDisplayed = 30;

   209 	picCount.iTotalPictures = 40;

   210 

   211 	return picCount;

   212 	}

   213 

   214 // picture counters comparison utility function 

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

   216 	{

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

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

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

   220 		 (a.iTotalPictures == b.iTotalPictures) )

   221 		 return ETrue;

   222 	else return EFalse;

   223 	}

   224 

   225 // bitstream counters creation utility function

   226 static inline CMMFDevVideoPlay::TBitstreamCounters GetTestBitstreamCounters( void )

   227 	{

   228 	CMMFDevVideoPlay::TBitstreamCounters bitCount;

   229  	

   230 	bitCount.iLostPackets = 256;

   231 	bitCount.iTotalPackets = 512;

   232 	

   233 	return bitCount;

   234 	}

   235 

   236 // bitstream counters comparison utility function 

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

   238 	{

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

   240 		 (a.iTotalPackets == b.iTotalPackets) )

   241 		 return ETrue;

   242 	else return EFalse;

   243 	}

   244 

   245 // test num buffers

   246 const TUint KTestNumFreeBuffers = 4096;

   247 

   248 // complexity levels

   249 const TUint KTestComplexityLevel1 = 1;

   250 const TUint KTestComplexityLevel2 = 3;

   251 const TUint KTestNumComplexityLevels1 = 5;

   252 const TUint KTestNumComplexityLevels2 = 10;

   253 

   254 // complexity level info creation utility function

   255 static inline CMMFDevVideoPlay::TComplexityLevelInfo GetTestLevelInfo( TInt a )

   256 	{

   257 	CMMFDevVideoPlay::TComplexityLevelInfo levInfo;

   258  	

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

   260 	levInfo.iAvgPictureRate = 1.5;

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

   262 	levInfo.iRelativeImageQuality = 0.5;

   263 	levInfo.iRequiredMIPS = a;

   264 	levInfo.iRelativeProcessTime = 0.3;

   265 	

   266 	return levInfo;

   267 	}

   268 

   269 // complexity level info comparison utility function 

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

   271 	{

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

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

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

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

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

   277 		 (a.iRelativeProcessTime == b.iRelativeProcessTime) )

   278 		 return ETrue;

   279 	else return EFalse;

   280 	}

   281 

   282 // picture timestamp test data

   283 const TInt KTestPictureTimestamp = 12345;

   284 

   285 // input buffer test data

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

   287 const TUint32 KTestBufferOptions = TVideoInputBuffer::EDecodingTimestamp;

   288 const TUint KTestBufferSize = 20;

   289 

   290 // decoder info

   291 const TUint32 KTestDecoderInfoCount = 3;

   292 

   293 const TText8* const KTestDecoderInfoMimeArray[KTestDecoderInfoCount] = 

   294 	{

   295 	_S8("video/bunglevideo"), 

   296 	_S8("video/zippyvideo"),

   297 	_S8("video/georgevideo")

   298 	};

   299 

   300 _LIT(KTestDecoderInfoManufacturer, "fred bloggs plc");

   301 _LIT(KTestDecoderInfoIdentifier, "video funkifier");

   302 

   303 const TInt KTestDecoderInfoMaxSizeX = 256;

   304 const TInt KTestDecoderInfoMaxSizeY = 512;

   305 

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

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

   308 

   309 const TInt KTestDecoderInfoVersionMaj = 1;

   310 const TInt KTestDecoderInfoVersionMin = 2;

   311 const TInt KTestDecoderInfoVersionBuild = 3;

   312 // KTestDecoderInfoVersion = Maj.Min.Build;

   313 

   314 // post processor info

   315 const TUint32 KTestPostProcInfoCount = 3;

   316 _LIT(KTestPostProcInfoManufacturer, "honest sid inc");

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

   318 

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

   320 

   321 const TInt KTestPostProcInfoVersionMaj = 1;

   322 const TInt KTestPostProcInfoVersionMin = 2;

   323 const TInt KTestPostProcInfoVersionBuild = 3;

   324 // KTestPostProcInfoVersion = Maj.Min.Build;

   325 

   326 const TUint32 KTestPostProcInfoRotations = ERotate90Clockwise | ERotate90Anticlockwise | ERotate180;

   327 

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

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

   330 	{

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

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

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

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

   335 		 return ETrue;

   336 	else return EFalse;

   337 	}

   338 

   339 const TUncompressedVideoFormat KTestPostProcInfoFormatArray[KTestPostProcInfoCount] =

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

   341 

   342 const TUint32 KTestPostProcInfoCombsArray[KTestPostProcInfoCount] =

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

   344 

   345 const TScaleFactor KTestPostProcInfoScaleFactorsArray[KTestPostProcInfoCount] =

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

   347 

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

   349 	{

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

   351 		return ETrue;

   352 	else return EFalse;

   353 	}

   354 

   355 const TUncompressedVideoFormat KTestPostProcInfoNegativeFormat = {EYuvRawData};

   356 const TUint32 KTestPostProcInfoNegativeComb = EPpCustom;

   357 

   358 

   359 // video header information

   360 const TVideoDataUnitType KTestDataUnitType = EDuCodedPicture;

   361 const TVideoDataUnitEncapsulation KTestDataUnitEncap = EDuElementaryStream;

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

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

   364 const TInt KTestInputBufferTimestamp = 1000000;

   365 const TInt KTestPictureHeaderTimestamp = 2000000;

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

   367 

   368 // TPictureData

   369 const TInt KTestPictureDataSizeX = 57;

   370 const TInt KTestPictureDataSizeY = 18;

   371 

   372 // snapshot data

   373 const TInt KTestSnapshotTimestamp = 1000;

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

   375 

   376 // clock deviation

   377 const TUint KTestClockDeviationMS	 = 500000;		// 0.5 seconds

   378 const TUint KTestClockBigDeviationMS = 2000000;		// 2 seconds

   379 const TUint KTestClock2Seconds	  = 2000000;

   380 const TUint KTestClock4Seconds	  = 4000000;

   381 const TUint KTestClock18Seconds	  = 18000000;

   382 const TUint KTestClock20Seconds	  = 20000000;

   383 const TUint KTestClock22Seconds	  = 22000000;

   384 

   385 // devvideorecord specific test data

   386 const TInt KTestInputSize1X = 640; 

   387 const TInt KTestInputSize1Y = 480;

   388 

   389 const TInt KTestInputSize2X = 320; 

   390 const TInt KTestInputSize2Y = 200;

   391 

   392 const TInt KTestCamHandlePre = 1;

   393 const TInt KTestCamHandleEnc = 2;

   394 const TInt KTestCamHandleFatal = 666;

   395 

   396 const TReal KTestPictureRate = 29.97;

   397 

   398 // rgb data

   399 const TRgbRange KTestRgbRange1 = ERgbRangeFull;

   400 const TRgbRange KTestRgbRange2 = ERgbRange16to235;

   401 

   402 // output pad

   403 const TInt KTestPadX = 100;

   404 const TInt KTestPadY = 200;

   405 const TInt KTestPadPointX = 300;

   406 const TInt KTestPadPointY = 400;

   407 

   408 // color enhancement

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

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

   411 

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

   413 	{

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

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

   416 		 (a.iContrast == b.iContrast) )

   417 		 return ETrue;

   418 	else return EFalse;

   419 	}

   420 

   421 // custom pre process options

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

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

   424 

   425 const TReal KTestRandomAccessRate = 0.555;

   426 const TUint KTestNumBitrateLayers = 369;

   427 

   428 const TUint KTestLayer = 12;

   429 const TScalabilityType KTestScaleType = EScalabilityQualityFG;

   430 

   431 const TUint KTestMaxRefPics = 9;

   432 const TUint KTestMaxPicDelay = 111;

   433 

   434 // encoder buffer options creation utility function

   435 static inline TEncoderBufferOptions GetTestEncBufferOptions( void )

   436 	{

   437 	TEncoderBufferOptions buffOptions;

   438  	

   439 	buffOptions.iMaxPreEncoderBufferPictures = 10;

   440 	buffOptions.iHrdVbvSpec = KTestHrdVbvSpec;

   441 	buffOptions.iHrdVbvParams.Set(KTestHrdVbvParams);

   442 	buffOptions.iMaxOutputBufferSize = 100;

   443 	buffOptions.iMaxCodedPictureSize = 200;

   444 	buffOptions.iMaxCodedSegmentSize = 300;

   445 	buffOptions.iMinNumOutputBuffers = 400;

   446 

   447 	return buffOptions;

   448 	}

   449 

   450 // encoder buffer options comparison utility function 

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

   452 	{

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

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

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

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

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

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

   459 		 (a.iMinNumOutputBuffers == b.iMinNumOutputBuffers) )

   460 		 return ETrue;

   461 	else return EFalse;

   462 	}

   463 

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

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

   466 

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

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

   469 

   470 const TUint KTestProtectLevels = 444;

   471 const TUint KTestLevel = 11;

   472 const TUint KTestBitrate = 192;

   473 const TUint KTestStrength = EFecStrengthLow;

   474 

   475 const TInt KTestLossBurstLength = 123456;

   476 const TUint KTestLossRate = 8192;

   477 

   478 const TReal KTestErrorRate = 1.11;

   479 const TReal KTestStdDeviation = 2.22;

   480 

   481 const TUint KTestSizeBytes = 8;

   482 const TUint KTestSizeMacroblocks = 244;

   483 

   484 // encoder rate control options creation utility function

   485 static inline TRateControlOptions GetTestRateControlOptions( void )

   486 	{

   487 	TRateControlOptions rateOptions;

   488  	

   489 	rateOptions.iControl = EBrControlPicture;

   490 	rateOptions.iBitrate = 256;

   491 	rateOptions.iPictureQuality = 512;

   492 	rateOptions.iPictureRate = 1.234;

   493 	rateOptions.iQualityTemporalTradeoff = 4.321;

   494 	rateOptions.iLatencyQualityTradeoff = 5.678;

   495 

   496 	return rateOptions;

   497 	}

   498 

   499 // encoder rate control options comparison utility function 

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

   501 	{

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

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

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

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

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

   507 		 (a.iLatencyQualityTradeoff == b.iLatencyQualityTradeoff) )

   508 		 return ETrue;

   509 	else return EFalse;

   510 	}

   511 

   512 // scalability

   513 const TUint KTestNumSteps = 56;

   514 const TInLayerScalabilityType KTestLayerScaleType = EInLScalabilityTemporal;

   515 const TUint KTestBitrateShare1 = 666;

   516 const TUint KTestBitrateShare2 = 777;

   517 const TUint KTestPictureShare1 = 888;

   518 const TUint KTestPictureShare2 = 999;

   519 

   520 const TUint KTestPointPeriod = 2;

   521 

   522 // settings output

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

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

   525 

   526 // picture timestamp

   527 const TInt KTestEncPictureTimestamp = 98765;

   528 

   529 // supplemental info

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

   531 const TInt KTestSuppTime = 6000000;

   532 const TInt KTestSuppTimeCancel = 666666666;

   533 

   534 const TInt KTestRecordPosition = 999666333;

   535 

   536 const TUint KTestFreeBuffers = 9;

   537 const TUint KTestFreeBytes = 256;

   538 

   539 // picture counters creation utility function

   540 static inline CMMFDevVideoRecord::TPictureCounters GetTestEncPictureCounters( void )

   541 	{

   542 	CMMFDevVideoRecord::TPictureCounters picCount;

   543 

   544 	picCount.iPicturesSkippedBufferOverflow = 10;

   545 	picCount.iPicturesSkippedProcPower = 20;

   546 	picCount.iPicturesSkippedRateControl = 30;

   547 	picCount.iPicturesProcessed = 40;

   548 	picCount.iInputPictures = 50;

   549 	return picCount;

   550 	}

   551 

   552 // picture counters comparison utility function 

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

   554 	{

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

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

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

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

   559 		 (a.iInputPictures == b.iInputPictures ))

   560 		 return ETrue;

   561 	else return EFalse;

   562 	}

   563 

   564 const TInt KTestEncInputPictures = 10;

   565 

   566 const TInt KTestFrameStableX1 = 5;

   567 const TInt KTestFrameStableY1 = 10;

   568 const TInt KTestFrameStableX2 = 300;

   569 const TInt KTestFrameStableY2 = 200;

   570 

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

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

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

   574 

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

   576 	{

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

   578 	}

   579 

   580 // slice loss

   581 const TUint KTestFirstMacroblock = 50;

   582 const TUint KTestNumMacroblocks = 3;

   583 

   584 // ref picture data

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

   586 

   587 // start / stop / pause / resume positions

   588 const TInt KTestRecTimeStop	= 0;	

   589 

   590 const TInt KTestRecTimeStartEnc = 10;

   591 const TInt KTestRecTimePauseEnc = 20;

   592 const TInt KTestRecTimeResumeEnc = 30;

   593 

   594 const TInt KTestRecTimeStartPre = 40;

   595 const TInt KTestRecTimePausePre = 50;

   596 const TInt KTestRecTimeResumePre = 60;

   597 

   598 // command to start buffer creation

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

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

   601 

   602 // encoder info

   603 const TUint32 KTestEncoderInfoCount = 3;

   604 

   605 const TText8* const KTestEncoderInfoMimeArray[KTestEncoderInfoCount] = 

   606 	{

   607 	_S8("video/bunglevideo"), 

   608 	_S8("video/zippyvideo"),

   609 	_S8("video/georgevideo")

   610 	};

   611 

   612 _LIT(KTestEncoderInfoManufacturer, "bodgitt plc");

   613 _LIT(KTestEncoderInfoIdentifier, "video bodger");

   614 

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

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

   617 

   618 const TInt KTestEncoderInfoVersionMaj = 11;

   619 const TInt KTestEncoderInfoVersionMin = 22;

   620 const TInt KTestEncoderInfoVersionBuild = 33;

   621 // KTestEncoderInfoVersion = Maj.Min.Build;

   622 

   623 const TInt KTestEncoderInfoMaxSizeX = 256;

   624 const TInt KTestEncoderInfoMaxSizeY = 512;

   625 const TUint KTestEncoderInfoMaxUEPLevels = 5;

   626 const TUint KTestEncoderInfoMaxBitrate = 963;

   627 const TUint KTestEncoderInfoMaxILSSteps = 555;

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

   629 

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

   631 	{

   632 	TPictureRateAndSize rate;

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

   634 	TReal rIndex = aIndex;

   635 

   636 	rate.iPictureSize = size;

   637 	rate.iPictureRate = rIndex / 10.0;

   638 

   639 	aRate = rate;

   640 	}

   641 

   642 // Pre Processor Info

   643 _LIT(KTestPreProcInfoManufacturer, "iced inc");

   644 _LIT(KTestPreProcInfoIdentifier, "video munger");

   645 

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

   647 

   648 const TInt KTestPreProcInfoVersionMaj = 44;

   649 const TInt KTestPreProcInfoVersionMin = 55;

   650 const TInt KTestPreProcInfoVersionBuild = 66;

   651 // KTestPreProcInfoVersion = Maj.Min.Build;

   652 const TUint32 KTestPreProcInfoRotations = KTestRotate1 | KTestRotate2;

   653 const TUint32 KTestPreProcInfoRgbRanges = KTestRgbRange1 | KTestRgbRange2;

   654 

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

   656 

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

   658 	{

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

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

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

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

   663 	}

   664 

   665 const TUncompressedVideoFormat KTestPreProcInfoOutputFormatArray[KTestPostProcInfoCount] =

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

   667 

   668 const TUncompressedVideoFormat KTestPreProcInfoInputFormatArray[KTestPostProcInfoCount] =

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

   670 

   671 const TUncompressedVideoFormat KTestPreProcInfoNegativeFormat = {ERgbRawData};

   672 

   673 // Custom Interface UIDs

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

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

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

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

   678 

   679 #endif	// __TESTDEVVIDEOPLAYTESTDATA_H__