MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlugins/encoder.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     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 //

    15 

    16 #include "encoder.h"

    17 #include "../TestDevVideoPlayTestData.h"

    18 

    19 _LIT(KDevVideoEncoderPanicCategory, "DevVideoEncoder");

    20 void DevVideoEncoderPanic(TInt aReason)

    21 	{

    22 	User::Panic(KDevVideoEncoderPanicCategory, aReason);

    23 	}

    24 

    25 CMMFVideoEncodeHwDevice* CMMFTestVideoEncodeHwDevice::NewL(TAny* /*aInitParams*/)

    26 	{

    27 	CMMFTestVideoEncodeHwDevice* s = new(ELeave) CMMFTestVideoEncodeHwDevice;

    28 	return (STATIC_CAST(CMMFVideoEncodeHwDevice*, s));

    29 	}

    30 

    31 CMMFTestVideoEncodeHwDevice::CMMFTestVideoEncodeHwDevice()

    32 	{

    33 	}

    34 

    35 CMMFTestVideoEncodeHwDevice::~CMMFTestVideoEncodeHwDevice()

    36 	{

    37 	iDataBuffers.Reset();

    38 	iDataBuffers.Close();

    39 

    40 	// destroy objects in RArray

    41 	for (TInt i = 0; i < iOutputVidFormats.Count(); i++)

    42 		{

    43 		delete iOutputVidFormats[i];

    44 		}

    45 

    46 	iOutputVidFormats.Reset();

    47 	iOutputVidFormats.Close();

    48 

    49 	iInputVidFormats.Reset();

    50 	iInputVidFormats.Close();

    51 

    52 	iPictureRates.Reset();

    53 	iPictureRates.Close();

    54 	}

    55 

    56 TAny* CMMFTestVideoEncodeHwDevice::CustomInterface(TUid aInterface)

    57 	{

    58 	if (aInterface == KUidCustomInterfaceThree)

    59 		{

    60 		return this;//just want to return something non-null!

    61 		}

    62 	else

    63 		{

    64 		return NULL;

    65 		}

    66 	}

    67 

    68 CPreProcessorInfo* CMMFTestVideoEncodeHwDevice::PreProcessorInfoLC()

    69 	{

    70 	return NULL;

    71 	}

    72 

    73 void CMMFTestVideoEncodeHwDevice::SetInputFormatL(const TUncompressedVideoFormat& aFormat, const TSize& aPictureSize)

    74 	{

    75 	TSize testSize(KTestInputSize1X, KTestInputSize1Y);

    76 

    77 	if (!(aFormat == KTestVidFormat1) || !(aPictureSize == testSize))

    78 		User::Leave(KErrCorrupt);

    79 	}

    80 

    81 void CMMFTestVideoEncodeHwDevice::SetSourceCameraL(TInt aCameraHandle, TReal aPictureRate)

    82 	{

    83 	if (aCameraHandle == KTestCamHandleFatal)

    84 		iProxy->MdvrpFatalError(this, KErrDied);

    85 	else if ((KTestCamHandleEnc != aCameraHandle) || (KTestPictureRate != aPictureRate))

    86 		User::Leave(KErrCorrupt);

    87 	}

    88 

    89 void CMMFTestVideoEncodeHwDevice::SetSourceMemoryL(TReal /*aMaxPictureRate*/, TBool /*aConstantPictureRate*/, TBool /*aProcessRealtime*/)

    90 	{

    91 	DevVideoEncoderPanic(EEncoderPanicSourceMem);

    92 	}

    93 

    94 void CMMFTestVideoEncodeHwDevice::SetClockSource(MMMFClockSource* aClock) 

    95 	{

    96 	__ASSERT_ALWAYS(aClock, DevVideoEncoderPanic(EEncoderPanicClockSource)); 

    97 

    98 	// call Time() to check that clock can be used

    99 	TTimeIntervalMicroSeconds currTime(0); // done this way to remove compiler warning

   100 	currTime = aClock->Time();

   101 	}

   102 

   103 void CMMFTestVideoEncodeHwDevice::SetPreProcessTypesL(TUint32 aPreProcessTypes)

   104 	{

   105 	if (!(aPreProcessTypes == KTestProcessType1))

   106 		User::Leave(KErrCorrupt);

   107 	}

   108 

   109 void CMMFTestVideoEncodeHwDevice::SetRgbToYuvOptionsL(TRgbRange aRange, const TYuvFormat& aOutputFormat)

   110 	{

   111 	// check against test data

   112 	if ((aRange != KTestRgbRange1) || !CompareYuvFormats(aOutputFormat, KTestYuvFormat1) )

   113 		User::Leave(KErrCorrupt);

   114 	}

   115 

   116 void CMMFTestVideoEncodeHwDevice::SetYuvToYuvOptionsL(const TYuvFormat& aInputFormat, const TYuvFormat& aOutputFormat)

   117 	{

   118 	if (!CompareYuvFormats(aInputFormat, KTestYuvFormat1) || !CompareYuvFormats(aOutputFormat, KTestYuvFormat2) )

   119 		User::Leave(KErrCorrupt);

   120 	}

   121 

   122 void CMMFTestVideoEncodeHwDevice::SetRotateOptionsL(TRotationType aRotationType)

   123 	{

   124 	if (!(aRotationType == KTestRotate1))

   125 		User::Leave(KErrCorrupt);

   126 	}

   127 

   128 void CMMFTestVideoEncodeHwDevice::SetScaleOptionsL(const TSize& aTargetSize, TBool aAntiAliasFiltering)

   129 	{

   130 	TSize testScale(KTestScaleX, KTestScaleY);

   131 	if (!(aTargetSize == testScale) || !aAntiAliasFiltering)

   132 		User::Leave(KErrCorrupt);

   133 	}

   134 

   135 void CMMFTestVideoEncodeHwDevice::SetInputCropOptionsL(const TRect& aRect)

   136 	{

   137 	TRect testRect(KTestInputCropRectA, KTestInputCropRectB, KTestInputCropRectC, KTestInputCropRectD);

   138 	if (!(aRect == testRect))

   139 		User::Leave(KErrCorrupt);

   140 	}

   141 

   142 void CMMFTestVideoEncodeHwDevice::SetOutputCropOptionsL(const TRect& aRect)

   143 	{

   144 	TRect testRect(KTestOutputCropRectA, KTestOutputCropRectB, KTestOutputCropRectC, KTestOutputCropRectD);

   145 	if (!(aRect == testRect))

   146 		User::Leave(KErrCorrupt);

   147 	}

   148 

   149 void CMMFTestVideoEncodeHwDevice::SetOutputPadOptionsL(const TSize& aOutputSize, const TPoint& aPicturePos)

   150 	{

   151 	TSize testPad(KTestPadX, KTestPadY);

   152 	TPoint testPoint(KTestPadPointX, KTestPadPointY);

   153 

   154 	if (!(testPad == aOutputSize) || !(testPoint == aPicturePos))

   155 		User::Leave(KErrCorrupt);

   156 	}

   157 

   158 void CMMFTestVideoEncodeHwDevice::SetColorEnhancementOptionsL(const TColorEnhancementOptions& aOptions)

   159 	{

   160 	if (!CompareColorEnhancements(aOptions, KTestColorEnhance1))

   161 		User::Leave(KErrCorrupt);

   162 	}

   163 

   164 void CMMFTestVideoEncodeHwDevice::SetFrameStabilisationOptionsL(const TSize& aOutputSize, TBool aFrameStabilisation)

   165 	{

   166 	TSize testSize(KTestScaleX, KTestScaleY);

   167 	if (!(aOutputSize == testSize) || !aFrameStabilisation)

   168 		User::Leave(KErrCorrupt);

   169 	}

   170 

   171 void CMMFTestVideoEncodeHwDevice::SetCustomPreProcessOptionsL(const TDesC8& aOptions)

   172 	{

   173 	if (!(aOptions == KTestCustomPreProc1))

   174 		User::Leave(KErrCorrupt);

   175 	}

   176 

   177 void CMMFTestVideoEncodeHwDevice::Initialize()

   178 	{

   179 	iProxy->MdvrpInitializeComplete(this, KErrNone);

   180 	}

   181 

   182 void CMMFTestVideoEncodeHwDevice::WritePictureL(TVideoPicture* aPicture)

   183 	{

   184 	// change the timestamp to the encoder timestamp

   185 	aPicture->iTimestamp = KTestEncPictureTimestamp;

   186 

   187 	iProxy->MdvrpReturnPicture(aPicture);

   188 	}

   189 

   190 void CMMFTestVideoEncodeHwDevice::InputEnd()

   191 	{

   192 	iProxy->MdvrpStreamEnd();

   193 	}

   194 

   195 void CMMFTestVideoEncodeHwDevice::Start()

   196 	{

   197 	iRecPosition = KTestRecTimeStartEnc;

   198 	iIsRecording = ETrue;

   199 

   200 	// if we're doing the buffer tests, start sending buffers to DevVideo

   201 	if (iDataBuffers.Count() > 0)

   202 		{

   203 		iProxy->MdvrpNewBuffer(&(iDataBuffers[0]));

   204 		}

   205 	}

   206 

   207 void CMMFTestVideoEncodeHwDevice::Stop()

   208 	{

   209 	iRecPosition = KTestRecTimeStop;

   210 	iIsRecording = EFalse;

   211 	}

   212 

   213 void CMMFTestVideoEncodeHwDevice::Pause()

   214 	{

   215 	iRecPosition = KTestRecTimePauseEnc;

   216 	iIsRecording = EFalse;

   217 	}

   218 

   219 void CMMFTestVideoEncodeHwDevice::Resume()

   220 	{

   221 	iRecPosition = KTestRecTimeResumeEnc;

   222 	iIsRecording = ETrue;

   223 	}

   224 

   225 void CMMFTestVideoEncodeHwDevice::Freeze()

   226 	{

   227 	}

   228 

   229 void CMMFTestVideoEncodeHwDevice::ReleaseFreeze()

   230 	{

   231 	}

   232 

   233 TTimeIntervalMicroSeconds CMMFTestVideoEncodeHwDevice::RecordingPosition()

   234 	{

   235 	return iRecPosition;

   236 	}

   237 

   238 void CMMFTestVideoEncodeHwDevice::GetPictureCounters(CMMFDevVideoRecord::TPictureCounters& aCounters)

   239 	{	

   240 	CMMFDevVideoRecord::TPictureCounters pic = GetTestEncPictureCounters(); 

   241 	

   242 	// adjust picture counters to differentiate encoder from preproc

   243 	pic.iInputPictures = KTestEncInputPictures;

   244 	aCounters = pic;

   245 	}

   246 

   247 void CMMFTestVideoEncodeHwDevice::GetFrameStabilisationOutput(TRect& aRect)

   248 	{

   249 	aRect = TRect(KTestFrameStableX1, KTestFrameStableY1, KTestFrameStableX2, KTestFrameStableY2);

   250 	}

   251 

   252 TUint CMMFTestVideoEncodeHwDevice::NumComplexityLevels()

   253 	{

   254 	return KTestNumComplexityLevels1;

   255 	}

   256 

   257 void CMMFTestVideoEncodeHwDevice::SetComplexityLevel(TUint aLevel)

   258 	{

   259 	__ASSERT_ALWAYS(aLevel == KTestComplexityLevel1, DevVideoEncoderPanic(EEncoderPanicComplexityLevel));

   260 	}

   261 

   262 CVideoEncoderInfo* CMMFTestVideoEncodeHwDevice::VideoEncoderInfoLC()

   263 	{

   264 	// construct array of test types

   265 	for (TUint i = 0; i < KTestEncoderInfoCount; i++)

   266 		{

   267 		// construct the video types for iOutputVidTypes

   268 		// use the same test data as for the decoder

   269 		CCompressedVideoFormat* vidCV = NULL;

   270 		TPtrC8 mimeType = KTestDecoderInfoMimeArray[i];

   271 		vidCV = GetTestCVFormatL(mimeType);

   272 		CleanupStack::PushL(vidCV);

   273 		User::LeaveIfError(iOutputVidFormats.Append(vidCV));

   274 		CleanupStack::Pop(vidCV);	// CCompressedVideo object is destroyed in destructor

   275 

   276 		// append the uncompressed video formats

   277 		TUncompressedVideoFormat vidUC = KTestPostProcInfoFormatArray[i];

   278 		User::LeaveIfError(iInputVidFormats.Append(vidUC));

   279 

   280 		// append the max picture rates

   281 		TPictureRateAndSize rate;

   282 		GetTestEncoderInfoRate(i, rate);

   283 		User::LeaveIfError(iPictureRates.Append(rate));

   284 		}

   285 	

   286 	// construct the video Encoder info object

   287 	CVideoEncoderInfo* vInfo = CVideoEncoderInfo::NewL(

   288 		KUidDevVideoTestEncodeHwDevice,

   289 		KTestEncoderInfoManufacturer,

   290 		KTestEncoderInfoIdentifier,

   291 		TVersion(KTestEncoderInfoVersionMaj, KTestEncoderInfoVersionMin, KTestEncoderInfoVersionBuild),

   292 		ETrue, // accelerated

   293 		ETrue, // supports direct capture

   294 		iInputVidFormats.Array(),

   295 		iOutputVidFormats.Array(),

   296 		TSize(KTestEncoderInfoMaxSizeX, KTestEncoderInfoMaxSizeY),

   297 		KTestUnitType1,

   298 		KTestEncapType1,

   299 		KTestNumBitrateLayers,

   300 		ETrue, // supports supplemental enhancement info

   301 		KTestEncoderInfoMaxUEPLevels,

   302 		KTestEncoderInfoMaxBitrate,

   303 		iPictureRates.Array(),

   304 		KTestEncoderInfoMaxILSSteps,

   305 		KTestEncoderInfoPictureOptions,

   306 		EFalse, // aSupportsPictureLoss,

   307 		ETrue, // aSupportsSliceLoss,

   308 		KTestEncoderInfoCSInfo,

   309 		KTestEncoderInfoISInfo );

   310 		

   311 

   312 	CleanupStack::PushL(vInfo);

   313 	return vInfo;

   314 	}

   315 

   316 void CMMFTestVideoEncodeHwDevice::SetOutputFormatL(const CCompressedVideoFormat& aFormat, 

   317 					  TVideoDataUnitType aDataUnitType, 					

   318 					  TVideoDataUnitEncapsulation aDataEncapsulation,

   319 					  TBool aSegmentationAllowed)

   320 	{

   321 	// check expected parameters - TClasses first

   322 	if (!((aDataUnitType == KTestUnitType1) && (aDataEncapsulation == KTestEncapType1) && aSegmentationAllowed))

   323 		User::Leave(KErrCorrupt);

   324 	

   325 	// construct a temporary compressed video class	[will leave on error]

   326 	CCompressedVideoFormat *compVideo = GetTestCVFormatL(KTestMimeType1);

   327 	CleanupStack::PushL(compVideo);

   328 

   329 	// compare to received class

   330 	if (!(aFormat == *compVideo))

   331 		User::Leave(KErrCorrupt);

   332 

   333 	// destroy temporary class

   334 	CleanupStack::PopAndDestroy(compVideo);

   335 	}

   336 

   337 void CMMFTestVideoEncodeHwDevice::SetOutputRectL(const TRect& aRect)

   338 	{

   339 	TRect testRect1(KTestInputCropRectA, KTestInputCropRectB, KTestInputCropRectC, KTestInputCropRectD);

   340 

   341 	if (!(aRect == testRect1))

   342 		User::Leave(KErrCorrupt);

   343 	}

   344 

   345 void CMMFTestVideoEncodeHwDevice::SetInputDevice(CMMFVideoPreProcHwDevice* /*aDevice*/)

   346 	{

   347 	}

   348 

   349 void CMMFTestVideoEncodeHwDevice::SetErrorsExpected(TBool aBitErrors, TBool aPacketLosses)

   350 	{

   351 	__ASSERT_ALWAYS(aBitErrors && !aPacketLosses, DevVideoEncoderPanic(EEncoderPanicErrorsExpected)); 

   352 	}

   353 

   354 void CMMFTestVideoEncodeHwDevice::SetMinRandomAccessRate(TReal aRate)

   355 	{

   356 	__ASSERT_ALWAYS(aRate == KTestRandomAccessRate, DevVideoEncoderPanic(EEncoderPanicRandomAccessRate)); 

   357 	}

   358 

   359 void CMMFTestVideoEncodeHwDevice::SetNumBitrateLayersL(TUint aNumLayers)

   360 	{

   361 	if (aNumLayers != KTestNumBitrateLayers)

   362 		User::Leave(KErrCorrupt);

   363 	}

   364 

   365 void CMMFTestVideoEncodeHwDevice::SetScalabilityLayerTypeL(TUint aLayer, TScalabilityType aScalabilityType)

   366 	{

   367 	if ((aLayer != KTestLayer) || (aScalabilityType != KTestScaleType))

   368 		User::Leave(KErrCorrupt);

   369 	}

   370 

   371 void CMMFTestVideoEncodeHwDevice::SetGlobalReferenceOptions(TUint aMaxReferencePictures, TUint aMaxPictureOrderDelay)

   372 	{

   373 	__ASSERT_ALWAYS((aMaxReferencePictures == KTestMaxRefPics) && (aMaxPictureOrderDelay == KTestMaxPicDelay), DevVideoEncoderPanic(EEncoderPanicRandomAccessRate)); 

   374 	}

   375 

   376 void CMMFTestVideoEncodeHwDevice::SetLayerReferenceOptions(TUint aLayer, TUint aMaxReferencePictures, TUint aMaxPictureOrderDelay)

   377 	{

   378 	__ASSERT_ALWAYS((aMaxReferencePictures == KTestMaxRefPics) && (aMaxPictureOrderDelay == KTestMaxPicDelay) && (aLayer == KTestLayer), DevVideoEncoderPanic(EEncoderPanicRandomAccessRate)); 

   379 	}

   380 

   381 void CMMFTestVideoEncodeHwDevice::SetBufferOptionsL(const TEncoderBufferOptions& aOptions)

   382 	{

   383 	if ( !CompareEncBufferOptions(aOptions, GetTestEncBufferOptions()) )

   384 		User::Leave(KErrCorrupt);

   385 	}

   386 

   387 void CMMFTestVideoEncodeHwDevice::SetCodingStandardSpecificOptionsL(const TDesC8& aOptions)

   388 	{

   389 	if (!(aOptions == KTestCSEncoderOptions))

   390 		User::Leave(KErrCorrupt);

   391 	}

   392 

   393 void CMMFTestVideoEncodeHwDevice::SetImplementationSpecificEncoderOptionsL(const TDesC8& aOptions)

   394 	{

   395 	if (aOptions == KTestISEncoderOptions)

   396 		{

   397 		// running standard test

   398 		}

   399 	else if (aOptions == KTestISEncBuffers)

   400 		{

   401 		// Special test plugin feature: we're being told to start outputting

   402 		// video buffers up to DevVideo.

   403 		// Create 10 video buffers

   404 		iDataBuffers.Reset();

   405 		for (TInt i = 0; i < 10; i++)

   406 			{

   407 			// Create a video output buffer that only has a valid timestamp

   408 			TVideoOutputBuffer buf;

   409 			buf.iCaptureTimestamp = TTimeIntervalMicroSeconds(i);

   410 			buf.iImplementationSpecificData.Set(KTestISEncBufferData);

   411 			User::LeaveIfError(iDataBuffers.Append(buf));

   412 			}

   413 		}

   414 	else

   415 		{

   416 		User::Leave(KErrCorrupt);

   417 		}

   418 	}

   419 

   420 HBufC8* CMMFTestVideoEncodeHwDevice::CodingStandardSpecificInitOutputLC()

   421 	{

   422 	HBufC8* bob = KTestCSInitOutput().AllocL();

   423 	CleanupStack::PushL(bob);

   424 

   425 	return bob;

   426 	}

   427 

   428 HBufC8* CMMFTestVideoEncodeHwDevice::ImplementationSpecificInitOutputLC()

   429 	{

   430 	HBufC8* fred = KTestISInitOutput().AllocL();

   431 	CleanupStack::PushL(fred);

   432 

   433 	return fred;

   434 	}

   435 

   436 void CMMFTestVideoEncodeHwDevice::SetErrorProtectionLevelsL(TUint aNumLevels, TBool aSeparateBuffers)

   437 	{

   438 	if ((aNumLevels != KTestProtectLevels) || !aSeparateBuffers)

   439 		User::Leave(KErrCorrupt);

   440 	}

   441 

   442 void CMMFTestVideoEncodeHwDevice::SetErrorProtectionLevelL(TUint aLevel, TUint aBitrate, TUint aStrength)

   443 	{

   444 	if ((aLevel != KTestLevel) || (aBitrate != KTestBitrate) || (aStrength != KTestStrength))

   445 		User::Leave(KErrCorrupt);

   446 	}

   447 

   448 void CMMFTestVideoEncodeHwDevice::SetChannelPacketLossRate(TUint aLevel, 

   449 							  TReal aLossRate, 

   450 							  TTimeIntervalMicroSeconds32 aLossBurstLength)

   451 	{

   452 	__ASSERT_ALWAYS((aLevel == KTestLevel) && (aLossRate == KTestLossRate) && (aLossBurstLength == TTimeIntervalMicroSeconds32(KTestLossBurstLength)), DevVideoEncoderPanic(EEncoderPanicPacketLossRate)); 

   453 	}

   454 

   455 void CMMFTestVideoEncodeHwDevice::SetChannelBitErrorRate(TUint aLevel, TReal aErrorRate, TReal aStdDeviation)

   456 	{

   457 	__ASSERT_ALWAYS((aLevel == KTestLevel) && (aErrorRate == KTestErrorRate) && (aStdDeviation == KTestStdDeviation), DevVideoEncoderPanic(EEncoderPanicBitErrorRate));	

   458 	}

   459 

   460 void CMMFTestVideoEncodeHwDevice::SetSegmentTargetSize(TUint aLayer, TUint aSizeBytes, TUint aSizeMacroblocks)

   461 	{

   462 	__ASSERT_ALWAYS((aLayer == KTestLayer) && (aSizeBytes == KTestSizeBytes) && (aSizeMacroblocks == KTestSizeMacroblocks), DevVideoEncoderPanic(EEncoderPanicSegmentTargetSize));	

   463 	}

   464 

   465 void CMMFTestVideoEncodeHwDevice::SetRateControlOptions(TUint aLayer, const TRateControlOptions& aOptions)

   466 	{

   467 	__ASSERT_ALWAYS(CompareRateControlOptions(aOptions, GetTestRateControlOptions()) && (aLayer == KTestLayer), DevVideoEncoderPanic(EEncoderPanicRateControlOptions)); 

   468 	}

   469 

   470 void CMMFTestVideoEncodeHwDevice::SetInLayerScalabilityL(TUint aLayer, TUint aNumSteps,

   471 							TInLayerScalabilityType aScalabilityType,

   472 							const TArray<TUint>& aBitrateShare,

   473 							const TArray<TUint>& aPictureShare)

   474 	{

   475 	// check the non-array classes first

   476 	if ((aLayer != KTestLayer) || (aNumSteps != KTestNumSteps) || (aScalabilityType != KTestLayerScaleType) )

   477 		User::Leave(KErrCorrupt);

   478 

   479 	TBool successBit = EFalse;

   480 	TBool successPic = EFalse;

   481 

   482 	// bitrateShare array

   483 	if (aBitrateShare.Count() == 2)

   484 		{

   485 		if ((aBitrateShare[0] == KTestBitrateShare1) && (aBitrateShare[1] == KTestBitrateShare2))

   486 			{

   487 			successBit = ETrue;

   488 			}

   489 		}

   490 

   491 	// pictureShare array

   492 	if (aPictureShare.Count() == 2)

   493 		{

   494 		if ((aPictureShare[0] == KTestPictureShare1) && (aPictureShare[1] == KTestPictureShare2))

   495 			{

   496 			successPic = ETrue;

   497 			}

   498 		}

   499 

   500 	if (!successBit || !successPic)

   501 		User::Leave(KErrCorrupt);

   502 	}

   503 

   504 void CMMFTestVideoEncodeHwDevice::SetLayerPromotionPointPeriod(TUint aLayer, TUint aPeriod)

   505 	{

   506 	__ASSERT_ALWAYS((aLayer == KTestLayer) && (aPeriod == KTestPointPeriod), DevVideoEncoderPanic(EEncoderPanicPointPromPeriod)); 

   507 	}

   508 

   509 HBufC8* CMMFTestVideoEncodeHwDevice::CodingStandardSpecificSettingsOutputLC()

   510 	{

   511 	HBufC8* chaz = KTestCSSettingsOutput().AllocL();

   512 	CleanupStack::PushL(chaz);

   513 

   514 	return chaz;

   515 	}

   516 

   517 HBufC8* CMMFTestVideoEncodeHwDevice::ImplementationSpecificSettingsOutputLC()

   518 	{

   519 	HBufC8* dave = KTestISSettingsOutput().AllocL();

   520 	CleanupStack::PushL(dave);

   521 

   522 	return dave;

   523 	}

   524 

   525 void CMMFTestVideoEncodeHwDevice::SendSupplementalInfoL(const TDesC8& aData)

   526 	{

   527 	if (!(aData == KTestSuppInfo))

   528 		User::Leave(KErrCorrupt);

   529 

   530 	iProxy->MdvrpSupplementalInfoSent();	

   531 	}

   532 

   533 void CMMFTestVideoEncodeHwDevice::SendSupplementalInfoL(const TDesC8& aData, const TTimeIntervalMicroSeconds& aTimestamp)

   534 	{

   535 	if (!(aData == KTestSuppInfo))

   536 		User::Leave(KErrCorrupt);

   537 

   538 	TTimeIntervalMicroSeconds suppTime(KTestSuppTime);

   539 	TTimeIntervalMicroSeconds suppTimeCancel(KTestSuppTimeCancel);

   540 

   541 	// check time stamp

   542 	if (!(aTimestamp == TTimeIntervalMicroSeconds(suppTime)) && 

   543 		!(aTimestamp == TTimeIntervalMicroSeconds(suppTimeCancel) ))

   544 		User::Leave(KErrCorrupt);

   545 

   546 	iSuppTime = ETrue;

   547 

   548 	// don't send callback if cancel supp time requested

   549 	if (aTimestamp == suppTime)

   550 		iProxy->MdvrpSupplementalInfoSent();

   551 	}

   552 

   553 void CMMFTestVideoEncodeHwDevice::CancelSupplementalInfo()

   554 	{

   555 	if (iSuppTime)

   556 		iProxy->MdvrpSupplementalInfoSent();

   557 	

   558 	iSuppTime = EFalse;

   559 	}

   560 

   561 void CMMFTestVideoEncodeHwDevice::GetOutputBufferStatus(TUint& aNumFreeBuffers, TUint& aTotalFreeBytes)

   562 	{

   563 	aNumFreeBuffers = KTestFreeBuffers;

   564 	aTotalFreeBytes = KTestFreeBytes;

   565 	}

   566 

   567 void CMMFTestVideoEncodeHwDevice::ReturnBuffer(TVideoOutputBuffer* /*aBuffer*/)

   568 	{

   569 	switch (iCurrentBuffer)

   570 		{

   571 	case 0:

   572 		// Send two more buffers

   573 		iCurrentBuffer = 1;

   574 		iProxy->MdvrpNewBuffer(&(iDataBuffers[1]));

   575 		iCurrentBuffer = 2;

   576 		iProxy->MdvrpNewBuffer(&(iDataBuffers[2]));

   577 		break;

   578 	case 2:

   579 		// Send three more buffers

   580 		iCurrentBuffer = 3;

   581 		iProxy->MdvrpNewBuffer(&(iDataBuffers[3]));

   582 		iCurrentBuffer = 4;

   583 		iProxy->MdvrpNewBuffer(&(iDataBuffers[4]));

   584 		iCurrentBuffer = 5;

   585 		iProxy->MdvrpNewBuffer(&(iDataBuffers[5]));

   586 		break;

   587 	case 5:

   588 		// Send the rest of the buffers

   589 		iCurrentBuffer = 6;

   590 		iProxy->MdvrpNewBuffer(&(iDataBuffers[6]));

   591 		iCurrentBuffer = 7;

   592 		iProxy->MdvrpNewBuffer(&(iDataBuffers[7]));

   593 		iCurrentBuffer = 8;

   594 		iProxy->MdvrpNewBuffer(&(iDataBuffers[8]));

   595 		iCurrentBuffer = 9;

   596 		iProxy->MdvrpNewBuffer(&(iDataBuffers[9]));

   597 		break;

   598 	default:

   599 		break;

   600 		};

   601 	}

   602 

   603 void CMMFTestVideoEncodeHwDevice::PictureLoss()

   604 	{

   605 	}

   606 

   607 void CMMFTestVideoEncodeHwDevice::PictureLoss(const TArray<TPictureId>& aPictures)

   608 	{

   609 	TBool success = EFalse;

   610 

   611 	if (aPictures.Count() == 3)

   612 		{

   613 		if (ComparePictureIDs(aPictures[0], KTestPictureId1) &&

   614 			ComparePictureIDs(aPictures[1], KTestPictureId2) &&

   615 			ComparePictureIDs(aPictures[2], KTestPictureId3) )

   616 			{

   617 			success = ETrue;

   618 			}

   619 		}

   620 

   621 	__ASSERT_ALWAYS(success, DevVideoEncoderPanic(EEncoderPanicPictureLossSpec)); 

   622 	}

   623 

   624 void CMMFTestVideoEncodeHwDevice::SliceLoss(TUint aFirstMacroblock, TUint aNumMacroblocks, const TPictureId& aPicture)

   625 	{

   626 	__ASSERT_ALWAYS((aFirstMacroblock == KTestFirstMacroblock) && 

   627 					(aNumMacroblocks == KTestNumMacroblocks) && 

   628 					ComparePictureIDs(aPicture, KTestPictureId1), DevVideoEncoderPanic(EEncoderPanicSliceLoss)); 

   629 	}

   630 

   631 void CMMFTestVideoEncodeHwDevice::ReferencePictureSelection(const TDesC8& aSelectionData)

   632 	{

   633 	__ASSERT_ALWAYS((aSelectionData == KTestRefPictureInfo), DevVideoEncoderPanic(EEncoderPanicRefPictureInfo));

   634 	}

   635 

   636 void CMMFTestVideoEncodeHwDevice::CommitL()

   637 	{

   638 	}

   639 

   640 void CMMFTestVideoEncodeHwDevice::Revert()

   641 	{

   642 	}

   643 

   644 void CMMFTestVideoEncodeHwDevice::SetProxy(MMMFDevVideoRecordProxy& aProxy)

   645 	{

   646 	ASSERT(iProxy == NULL);

   647 	iProxy = &aProxy;

   648 	}

   649
Symaptic