1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/mm/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlugins/encoder.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,649 @@
1.4 +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "encoder.h"
1.20 +#include "../TestDevVideoPlayTestData.h"
1.21 +
1.22 +_LIT(KDevVideoEncoderPanicCategory, "DevVideoEncoder");
1.23 +void DevVideoEncoderPanic(TInt aReason)
1.24 + {
1.25 + User::Panic(KDevVideoEncoderPanicCategory, aReason);
1.26 + }
1.27 +
1.28 +CMMFVideoEncodeHwDevice* CMMFTestVideoEncodeHwDevice::NewL(TAny* /*aInitParams*/)
1.29 + {
1.30 + CMMFTestVideoEncodeHwDevice* s = new(ELeave) CMMFTestVideoEncodeHwDevice;
1.31 + return (STATIC_CAST(CMMFVideoEncodeHwDevice*, s));
1.32 + }
1.33 +
1.34 +CMMFTestVideoEncodeHwDevice::CMMFTestVideoEncodeHwDevice()
1.35 + {
1.36 + }
1.37 +
1.38 +CMMFTestVideoEncodeHwDevice::~CMMFTestVideoEncodeHwDevice()
1.39 + {
1.40 + iDataBuffers.Reset();
1.41 + iDataBuffers.Close();
1.42 +
1.43 + // destroy objects in RArray
1.44 + for (TInt i = 0; i < iOutputVidFormats.Count(); i++)
1.45 + {
1.46 + delete iOutputVidFormats[i];
1.47 + }
1.48 +
1.49 + iOutputVidFormats.Reset();
1.50 + iOutputVidFormats.Close();
1.51 +
1.52 + iInputVidFormats.Reset();
1.53 + iInputVidFormats.Close();
1.54 +
1.55 + iPictureRates.Reset();
1.56 + iPictureRates.Close();
1.57 + }
1.58 +
1.59 +TAny* CMMFTestVideoEncodeHwDevice::CustomInterface(TUid aInterface)
1.60 + {
1.61 + if (aInterface == KUidCustomInterfaceThree)
1.62 + {
1.63 + return this;//just want to return something non-null!
1.64 + }
1.65 + else
1.66 + {
1.67 + return NULL;
1.68 + }
1.69 + }
1.70 +
1.71 +CPreProcessorInfo* CMMFTestVideoEncodeHwDevice::PreProcessorInfoLC()
1.72 + {
1.73 + return NULL;
1.74 + }
1.75 +
1.76 +void CMMFTestVideoEncodeHwDevice::SetInputFormatL(const TUncompressedVideoFormat& aFormat, const TSize& aPictureSize)
1.77 + {
1.78 + TSize testSize(KTestInputSize1X, KTestInputSize1Y);
1.79 +
1.80 + if (!(aFormat == KTestVidFormat1) || !(aPictureSize == testSize))
1.81 + User::Leave(KErrCorrupt);
1.82 + }
1.83 +
1.84 +void CMMFTestVideoEncodeHwDevice::SetSourceCameraL(TInt aCameraHandle, TReal aPictureRate)
1.85 + {
1.86 + if (aCameraHandle == KTestCamHandleFatal)
1.87 + iProxy->MdvrpFatalError(this, KErrDied);
1.88 + else if ((KTestCamHandleEnc != aCameraHandle) || (KTestPictureRate != aPictureRate))
1.89 + User::Leave(KErrCorrupt);
1.90 + }
1.91 +
1.92 +void CMMFTestVideoEncodeHwDevice::SetSourceMemoryL(TReal /*aMaxPictureRate*/, TBool /*aConstantPictureRate*/, TBool /*aProcessRealtime*/)
1.93 + {
1.94 + DevVideoEncoderPanic(EEncoderPanicSourceMem);
1.95 + }
1.96 +
1.97 +void CMMFTestVideoEncodeHwDevice::SetClockSource(MMMFClockSource* aClock)
1.98 + {
1.99 + __ASSERT_ALWAYS(aClock, DevVideoEncoderPanic(EEncoderPanicClockSource));
1.100 +
1.101 + // call Time() to check that clock can be used
1.102 + TTimeIntervalMicroSeconds currTime(0); // done this way to remove compiler warning
1.103 + currTime = aClock->Time();
1.104 + }
1.105 +
1.106 +void CMMFTestVideoEncodeHwDevice::SetPreProcessTypesL(TUint32 aPreProcessTypes)
1.107 + {
1.108 + if (!(aPreProcessTypes == KTestProcessType1))
1.109 + User::Leave(KErrCorrupt);
1.110 + }
1.111 +
1.112 +void CMMFTestVideoEncodeHwDevice::SetRgbToYuvOptionsL(TRgbRange aRange, const TYuvFormat& aOutputFormat)
1.113 + {
1.114 + // check against test data
1.115 + if ((aRange != KTestRgbRange1) || !CompareYuvFormats(aOutputFormat, KTestYuvFormat1) )
1.116 + User::Leave(KErrCorrupt);
1.117 + }
1.118 +
1.119 +void CMMFTestVideoEncodeHwDevice::SetYuvToYuvOptionsL(const TYuvFormat& aInputFormat, const TYuvFormat& aOutputFormat)
1.120 + {
1.121 + if (!CompareYuvFormats(aInputFormat, KTestYuvFormat1) || !CompareYuvFormats(aOutputFormat, KTestYuvFormat2) )
1.122 + User::Leave(KErrCorrupt);
1.123 + }
1.124 +
1.125 +void CMMFTestVideoEncodeHwDevice::SetRotateOptionsL(TRotationType aRotationType)
1.126 + {
1.127 + if (!(aRotationType == KTestRotate1))
1.128 + User::Leave(KErrCorrupt);
1.129 + }
1.130 +
1.131 +void CMMFTestVideoEncodeHwDevice::SetScaleOptionsL(const TSize& aTargetSize, TBool aAntiAliasFiltering)
1.132 + {
1.133 + TSize testScale(KTestScaleX, KTestScaleY);
1.134 + if (!(aTargetSize == testScale) || !aAntiAliasFiltering)
1.135 + User::Leave(KErrCorrupt);
1.136 + }
1.137 +
1.138 +void CMMFTestVideoEncodeHwDevice::SetInputCropOptionsL(const TRect& aRect)
1.139 + {
1.140 + TRect testRect(KTestInputCropRectA, KTestInputCropRectB, KTestInputCropRectC, KTestInputCropRectD);
1.141 + if (!(aRect == testRect))
1.142 + User::Leave(KErrCorrupt);
1.143 + }
1.144 +
1.145 +void CMMFTestVideoEncodeHwDevice::SetOutputCropOptionsL(const TRect& aRect)
1.146 + {
1.147 + TRect testRect(KTestOutputCropRectA, KTestOutputCropRectB, KTestOutputCropRectC, KTestOutputCropRectD);
1.148 + if (!(aRect == testRect))
1.149 + User::Leave(KErrCorrupt);
1.150 + }
1.151 +
1.152 +void CMMFTestVideoEncodeHwDevice::SetOutputPadOptionsL(const TSize& aOutputSize, const TPoint& aPicturePos)
1.153 + {
1.154 + TSize testPad(KTestPadX, KTestPadY);
1.155 + TPoint testPoint(KTestPadPointX, KTestPadPointY);
1.156 +
1.157 + if (!(testPad == aOutputSize) || !(testPoint == aPicturePos))
1.158 + User::Leave(KErrCorrupt);
1.159 + }
1.160 +
1.161 +void CMMFTestVideoEncodeHwDevice::SetColorEnhancementOptionsL(const TColorEnhancementOptions& aOptions)
1.162 + {
1.163 + if (!CompareColorEnhancements(aOptions, KTestColorEnhance1))
1.164 + User::Leave(KErrCorrupt);
1.165 + }
1.166 +
1.167 +void CMMFTestVideoEncodeHwDevice::SetFrameStabilisationOptionsL(const TSize& aOutputSize, TBool aFrameStabilisation)
1.168 + {
1.169 + TSize testSize(KTestScaleX, KTestScaleY);
1.170 + if (!(aOutputSize == testSize) || !aFrameStabilisation)
1.171 + User::Leave(KErrCorrupt);
1.172 + }
1.173 +
1.174 +void CMMFTestVideoEncodeHwDevice::SetCustomPreProcessOptionsL(const TDesC8& aOptions)
1.175 + {
1.176 + if (!(aOptions == KTestCustomPreProc1))
1.177 + User::Leave(KErrCorrupt);
1.178 + }
1.179 +
1.180 +void CMMFTestVideoEncodeHwDevice::Initialize()
1.181 + {
1.182 + iProxy->MdvrpInitializeComplete(this, KErrNone);
1.183 + }
1.184 +
1.185 +void CMMFTestVideoEncodeHwDevice::WritePictureL(TVideoPicture* aPicture)
1.186 + {
1.187 + // change the timestamp to the encoder timestamp
1.188 + aPicture->iTimestamp = KTestEncPictureTimestamp;
1.189 +
1.190 + iProxy->MdvrpReturnPicture(aPicture);
1.191 + }
1.192 +
1.193 +void CMMFTestVideoEncodeHwDevice::InputEnd()
1.194 + {
1.195 + iProxy->MdvrpStreamEnd();
1.196 + }
1.197 +
1.198 +void CMMFTestVideoEncodeHwDevice::Start()
1.199 + {
1.200 + iRecPosition = KTestRecTimeStartEnc;
1.201 + iIsRecording = ETrue;
1.202 +
1.203 + // if we're doing the buffer tests, start sending buffers to DevVideo
1.204 + if (iDataBuffers.Count() > 0)
1.205 + {
1.206 + iProxy->MdvrpNewBuffer(&(iDataBuffers[0]));
1.207 + }
1.208 + }
1.209 +
1.210 +void CMMFTestVideoEncodeHwDevice::Stop()
1.211 + {
1.212 + iRecPosition = KTestRecTimeStop;
1.213 + iIsRecording = EFalse;
1.214 + }
1.215 +
1.216 +void CMMFTestVideoEncodeHwDevice::Pause()
1.217 + {
1.218 + iRecPosition = KTestRecTimePauseEnc;
1.219 + iIsRecording = EFalse;
1.220 + }
1.221 +
1.222 +void CMMFTestVideoEncodeHwDevice::Resume()
1.223 + {
1.224 + iRecPosition = KTestRecTimeResumeEnc;
1.225 + iIsRecording = ETrue;
1.226 + }
1.227 +
1.228 +void CMMFTestVideoEncodeHwDevice::Freeze()
1.229 + {
1.230 + }
1.231 +
1.232 +void CMMFTestVideoEncodeHwDevice::ReleaseFreeze()
1.233 + {
1.234 + }
1.235 +
1.236 +TTimeIntervalMicroSeconds CMMFTestVideoEncodeHwDevice::RecordingPosition()
1.237 + {
1.238 + return iRecPosition;
1.239 + }
1.240 +
1.241 +void CMMFTestVideoEncodeHwDevice::GetPictureCounters(CMMFDevVideoRecord::TPictureCounters& aCounters)
1.242 + {
1.243 + CMMFDevVideoRecord::TPictureCounters pic = GetTestEncPictureCounters();
1.244 +
1.245 + // adjust picture counters to differentiate encoder from preproc
1.246 + pic.iInputPictures = KTestEncInputPictures;
1.247 + aCounters = pic;
1.248 + }
1.249 +
1.250 +void CMMFTestVideoEncodeHwDevice::GetFrameStabilisationOutput(TRect& aRect)
1.251 + {
1.252 + aRect = TRect(KTestFrameStableX1, KTestFrameStableY1, KTestFrameStableX2, KTestFrameStableY2);
1.253 + }
1.254 +
1.255 +TUint CMMFTestVideoEncodeHwDevice::NumComplexityLevels()
1.256 + {
1.257 + return KTestNumComplexityLevels1;
1.258 + }
1.259 +
1.260 +void CMMFTestVideoEncodeHwDevice::SetComplexityLevel(TUint aLevel)
1.261 + {
1.262 + __ASSERT_ALWAYS(aLevel == KTestComplexityLevel1, DevVideoEncoderPanic(EEncoderPanicComplexityLevel));
1.263 + }
1.264 +
1.265 +CVideoEncoderInfo* CMMFTestVideoEncodeHwDevice::VideoEncoderInfoLC()
1.266 + {
1.267 + // construct array of test types
1.268 + for (TUint i = 0; i < KTestEncoderInfoCount; i++)
1.269 + {
1.270 + // construct the video types for iOutputVidTypes
1.271 + // use the same test data as for the decoder
1.272 + CCompressedVideoFormat* vidCV = NULL;
1.273 + TPtrC8 mimeType = KTestDecoderInfoMimeArray[i];
1.274 + vidCV = GetTestCVFormatL(mimeType);
1.275 + CleanupStack::PushL(vidCV);
1.276 + User::LeaveIfError(iOutputVidFormats.Append(vidCV));
1.277 + CleanupStack::Pop(vidCV); // CCompressedVideo object is destroyed in destructor
1.278 +
1.279 + // append the uncompressed video formats
1.280 + TUncompressedVideoFormat vidUC = KTestPostProcInfoFormatArray[i];
1.281 + User::LeaveIfError(iInputVidFormats.Append(vidUC));
1.282 +
1.283 + // append the max picture rates
1.284 + TPictureRateAndSize rate;
1.285 + GetTestEncoderInfoRate(i, rate);
1.286 + User::LeaveIfError(iPictureRates.Append(rate));
1.287 + }
1.288 +
1.289 + // construct the video Encoder info object
1.290 + CVideoEncoderInfo* vInfo = CVideoEncoderInfo::NewL(
1.291 + KUidDevVideoTestEncodeHwDevice,
1.292 + KTestEncoderInfoManufacturer,
1.293 + KTestEncoderInfoIdentifier,
1.294 + TVersion(KTestEncoderInfoVersionMaj, KTestEncoderInfoVersionMin, KTestEncoderInfoVersionBuild),
1.295 + ETrue, // accelerated
1.296 + ETrue, // supports direct capture
1.297 + iInputVidFormats.Array(),
1.298 + iOutputVidFormats.Array(),
1.299 + TSize(KTestEncoderInfoMaxSizeX, KTestEncoderInfoMaxSizeY),
1.300 + KTestUnitType1,
1.301 + KTestEncapType1,
1.302 + KTestNumBitrateLayers,
1.303 + ETrue, // supports supplemental enhancement info
1.304 + KTestEncoderInfoMaxUEPLevels,
1.305 + KTestEncoderInfoMaxBitrate,
1.306 + iPictureRates.Array(),
1.307 + KTestEncoderInfoMaxILSSteps,
1.308 + KTestEncoderInfoPictureOptions,
1.309 + EFalse, // aSupportsPictureLoss,
1.310 + ETrue, // aSupportsSliceLoss,
1.311 + KTestEncoderInfoCSInfo,
1.312 + KTestEncoderInfoISInfo );
1.313 +
1.314 +
1.315 + CleanupStack::PushL(vInfo);
1.316 + return vInfo;
1.317 + }
1.318 +
1.319 +void CMMFTestVideoEncodeHwDevice::SetOutputFormatL(const CCompressedVideoFormat& aFormat,
1.320 + TVideoDataUnitType aDataUnitType,
1.321 + TVideoDataUnitEncapsulation aDataEncapsulation,
1.322 + TBool aSegmentationAllowed)
1.323 + {
1.324 + // check expected parameters - TClasses first
1.325 + if (!((aDataUnitType == KTestUnitType1) && (aDataEncapsulation == KTestEncapType1) && aSegmentationAllowed))
1.326 + User::Leave(KErrCorrupt);
1.327 +
1.328 + // construct a temporary compressed video class [will leave on error]
1.329 + CCompressedVideoFormat *compVideo = GetTestCVFormatL(KTestMimeType1);
1.330 + CleanupStack::PushL(compVideo);
1.331 +
1.332 + // compare to received class
1.333 + if (!(aFormat == *compVideo))
1.334 + User::Leave(KErrCorrupt);
1.335 +
1.336 + // destroy temporary class
1.337 + CleanupStack::PopAndDestroy(compVideo);
1.338 + }
1.339 +
1.340 +void CMMFTestVideoEncodeHwDevice::SetOutputRectL(const TRect& aRect)
1.341 + {
1.342 + TRect testRect1(KTestInputCropRectA, KTestInputCropRectB, KTestInputCropRectC, KTestInputCropRectD);
1.343 +
1.344 + if (!(aRect == testRect1))
1.345 + User::Leave(KErrCorrupt);
1.346 + }
1.347 +
1.348 +void CMMFTestVideoEncodeHwDevice::SetInputDevice(CMMFVideoPreProcHwDevice* /*aDevice*/)
1.349 + {
1.350 + }
1.351 +
1.352 +void CMMFTestVideoEncodeHwDevice::SetErrorsExpected(TBool aBitErrors, TBool aPacketLosses)
1.353 + {
1.354 + __ASSERT_ALWAYS(aBitErrors && !aPacketLosses, DevVideoEncoderPanic(EEncoderPanicErrorsExpected));
1.355 + }
1.356 +
1.357 +void CMMFTestVideoEncodeHwDevice::SetMinRandomAccessRate(TReal aRate)
1.358 + {
1.359 + __ASSERT_ALWAYS(aRate == KTestRandomAccessRate, DevVideoEncoderPanic(EEncoderPanicRandomAccessRate));
1.360 + }
1.361 +
1.362 +void CMMFTestVideoEncodeHwDevice::SetNumBitrateLayersL(TUint aNumLayers)
1.363 + {
1.364 + if (aNumLayers != KTestNumBitrateLayers)
1.365 + User::Leave(KErrCorrupt);
1.366 + }
1.367 +
1.368 +void CMMFTestVideoEncodeHwDevice::SetScalabilityLayerTypeL(TUint aLayer, TScalabilityType aScalabilityType)
1.369 + {
1.370 + if ((aLayer != KTestLayer) || (aScalabilityType != KTestScaleType))
1.371 + User::Leave(KErrCorrupt);
1.372 + }
1.373 +
1.374 +void CMMFTestVideoEncodeHwDevice::SetGlobalReferenceOptions(TUint aMaxReferencePictures, TUint aMaxPictureOrderDelay)
1.375 + {
1.376 + __ASSERT_ALWAYS((aMaxReferencePictures == KTestMaxRefPics) && (aMaxPictureOrderDelay == KTestMaxPicDelay), DevVideoEncoderPanic(EEncoderPanicRandomAccessRate));
1.377 + }
1.378 +
1.379 +void CMMFTestVideoEncodeHwDevice::SetLayerReferenceOptions(TUint aLayer, TUint aMaxReferencePictures, TUint aMaxPictureOrderDelay)
1.380 + {
1.381 + __ASSERT_ALWAYS((aMaxReferencePictures == KTestMaxRefPics) && (aMaxPictureOrderDelay == KTestMaxPicDelay) && (aLayer == KTestLayer), DevVideoEncoderPanic(EEncoderPanicRandomAccessRate));
1.382 + }
1.383 +
1.384 +void CMMFTestVideoEncodeHwDevice::SetBufferOptionsL(const TEncoderBufferOptions& aOptions)
1.385 + {
1.386 + if ( !CompareEncBufferOptions(aOptions, GetTestEncBufferOptions()) )
1.387 + User::Leave(KErrCorrupt);
1.388 + }
1.389 +
1.390 +void CMMFTestVideoEncodeHwDevice::SetCodingStandardSpecificOptionsL(const TDesC8& aOptions)
1.391 + {
1.392 + if (!(aOptions == KTestCSEncoderOptions))
1.393 + User::Leave(KErrCorrupt);
1.394 + }
1.395 +
1.396 +void CMMFTestVideoEncodeHwDevice::SetImplementationSpecificEncoderOptionsL(const TDesC8& aOptions)
1.397 + {
1.398 + if (aOptions == KTestISEncoderOptions)
1.399 + {
1.400 + // running standard test
1.401 + }
1.402 + else if (aOptions == KTestISEncBuffers)
1.403 + {
1.404 + // Special test plugin feature: we're being told to start outputting
1.405 + // video buffers up to DevVideo.
1.406 + // Create 10 video buffers
1.407 + iDataBuffers.Reset();
1.408 + for (TInt i = 0; i < 10; i++)
1.409 + {
1.410 + // Create a video output buffer that only has a valid timestamp
1.411 + TVideoOutputBuffer buf;
1.412 + buf.iCaptureTimestamp = TTimeIntervalMicroSeconds(i);
1.413 + buf.iImplementationSpecificData.Set(KTestISEncBufferData);
1.414 + User::LeaveIfError(iDataBuffers.Append(buf));
1.415 + }
1.416 + }
1.417 + else
1.418 + {
1.419 + User::Leave(KErrCorrupt);
1.420 + }
1.421 + }
1.422 +
1.423 +HBufC8* CMMFTestVideoEncodeHwDevice::CodingStandardSpecificInitOutputLC()
1.424 + {
1.425 + HBufC8* bob = KTestCSInitOutput().AllocL();
1.426 + CleanupStack::PushL(bob);
1.427 +
1.428 + return bob;
1.429 + }
1.430 +
1.431 +HBufC8* CMMFTestVideoEncodeHwDevice::ImplementationSpecificInitOutputLC()
1.432 + {
1.433 + HBufC8* fred = KTestISInitOutput().AllocL();
1.434 + CleanupStack::PushL(fred);
1.435 +
1.436 + return fred;
1.437 + }
1.438 +
1.439 +void CMMFTestVideoEncodeHwDevice::SetErrorProtectionLevelsL(TUint aNumLevels, TBool aSeparateBuffers)
1.440 + {
1.441 + if ((aNumLevels != KTestProtectLevels) || !aSeparateBuffers)
1.442 + User::Leave(KErrCorrupt);
1.443 + }
1.444 +
1.445 +void CMMFTestVideoEncodeHwDevice::SetErrorProtectionLevelL(TUint aLevel, TUint aBitrate, TUint aStrength)
1.446 + {
1.447 + if ((aLevel != KTestLevel) || (aBitrate != KTestBitrate) || (aStrength != KTestStrength))
1.448 + User::Leave(KErrCorrupt);
1.449 + }
1.450 +
1.451 +void CMMFTestVideoEncodeHwDevice::SetChannelPacketLossRate(TUint aLevel,
1.452 + TReal aLossRate,
1.453 + TTimeIntervalMicroSeconds32 aLossBurstLength)
1.454 + {
1.455 + __ASSERT_ALWAYS((aLevel == KTestLevel) && (aLossRate == KTestLossRate) && (aLossBurstLength == TTimeIntervalMicroSeconds32(KTestLossBurstLength)), DevVideoEncoderPanic(EEncoderPanicPacketLossRate));
1.456 + }
1.457 +
1.458 +void CMMFTestVideoEncodeHwDevice::SetChannelBitErrorRate(TUint aLevel, TReal aErrorRate, TReal aStdDeviation)
1.459 + {
1.460 + __ASSERT_ALWAYS((aLevel == KTestLevel) && (aErrorRate == KTestErrorRate) && (aStdDeviation == KTestStdDeviation), DevVideoEncoderPanic(EEncoderPanicBitErrorRate));
1.461 + }
1.462 +
1.463 +void CMMFTestVideoEncodeHwDevice::SetSegmentTargetSize(TUint aLayer, TUint aSizeBytes, TUint aSizeMacroblocks)
1.464 + {
1.465 + __ASSERT_ALWAYS((aLayer == KTestLayer) && (aSizeBytes == KTestSizeBytes) && (aSizeMacroblocks == KTestSizeMacroblocks), DevVideoEncoderPanic(EEncoderPanicSegmentTargetSize));
1.466 + }
1.467 +
1.468 +void CMMFTestVideoEncodeHwDevice::SetRateControlOptions(TUint aLayer, const TRateControlOptions& aOptions)
1.469 + {
1.470 + __ASSERT_ALWAYS(CompareRateControlOptions(aOptions, GetTestRateControlOptions()) && (aLayer == KTestLayer), DevVideoEncoderPanic(EEncoderPanicRateControlOptions));
1.471 + }
1.472 +
1.473 +void CMMFTestVideoEncodeHwDevice::SetInLayerScalabilityL(TUint aLayer, TUint aNumSteps,
1.474 + TInLayerScalabilityType aScalabilityType,
1.475 + const TArray<TUint>& aBitrateShare,
1.476 + const TArray<TUint>& aPictureShare)
1.477 + {
1.478 + // check the non-array classes first
1.479 + if ((aLayer != KTestLayer) || (aNumSteps != KTestNumSteps) || (aScalabilityType != KTestLayerScaleType) )
1.480 + User::Leave(KErrCorrupt);
1.481 +
1.482 + TBool successBit = EFalse;
1.483 + TBool successPic = EFalse;
1.484 +
1.485 + // bitrateShare array
1.486 + if (aBitrateShare.Count() == 2)
1.487 + {
1.488 + if ((aBitrateShare[0] == KTestBitrateShare1) && (aBitrateShare[1] == KTestBitrateShare2))
1.489 + {
1.490 + successBit = ETrue;
1.491 + }
1.492 + }
1.493 +
1.494 + // pictureShare array
1.495 + if (aPictureShare.Count() == 2)
1.496 + {
1.497 + if ((aPictureShare[0] == KTestPictureShare1) && (aPictureShare[1] == KTestPictureShare2))
1.498 + {
1.499 + successPic = ETrue;
1.500 + }
1.501 + }
1.502 +
1.503 + if (!successBit || !successPic)
1.504 + User::Leave(KErrCorrupt);
1.505 + }
1.506 +
1.507 +void CMMFTestVideoEncodeHwDevice::SetLayerPromotionPointPeriod(TUint aLayer, TUint aPeriod)
1.508 + {
1.509 + __ASSERT_ALWAYS((aLayer == KTestLayer) && (aPeriod == KTestPointPeriod), DevVideoEncoderPanic(EEncoderPanicPointPromPeriod));
1.510 + }
1.511 +
1.512 +HBufC8* CMMFTestVideoEncodeHwDevice::CodingStandardSpecificSettingsOutputLC()
1.513 + {
1.514 + HBufC8* chaz = KTestCSSettingsOutput().AllocL();
1.515 + CleanupStack::PushL(chaz);
1.516 +
1.517 + return chaz;
1.518 + }
1.519 +
1.520 +HBufC8* CMMFTestVideoEncodeHwDevice::ImplementationSpecificSettingsOutputLC()
1.521 + {
1.522 + HBufC8* dave = KTestISSettingsOutput().AllocL();
1.523 + CleanupStack::PushL(dave);
1.524 +
1.525 + return dave;
1.526 + }
1.527 +
1.528 +void CMMFTestVideoEncodeHwDevice::SendSupplementalInfoL(const TDesC8& aData)
1.529 + {
1.530 + if (!(aData == KTestSuppInfo))
1.531 + User::Leave(KErrCorrupt);
1.532 +
1.533 + iProxy->MdvrpSupplementalInfoSent();
1.534 + }
1.535 +
1.536 +void CMMFTestVideoEncodeHwDevice::SendSupplementalInfoL(const TDesC8& aData, const TTimeIntervalMicroSeconds& aTimestamp)
1.537 + {
1.538 + if (!(aData == KTestSuppInfo))
1.539 + User::Leave(KErrCorrupt);
1.540 +
1.541 + TTimeIntervalMicroSeconds suppTime(KTestSuppTime);
1.542 + TTimeIntervalMicroSeconds suppTimeCancel(KTestSuppTimeCancel);
1.543 +
1.544 + // check time stamp
1.545 + if (!(aTimestamp == TTimeIntervalMicroSeconds(suppTime)) &&
1.546 + !(aTimestamp == TTimeIntervalMicroSeconds(suppTimeCancel) ))
1.547 + User::Leave(KErrCorrupt);
1.548 +
1.549 + iSuppTime = ETrue;
1.550 +
1.551 + // don't send callback if cancel supp time requested
1.552 + if (aTimestamp == suppTime)
1.553 + iProxy->MdvrpSupplementalInfoSent();
1.554 + }
1.555 +
1.556 +void CMMFTestVideoEncodeHwDevice::CancelSupplementalInfo()
1.557 + {
1.558 + if (iSuppTime)
1.559 + iProxy->MdvrpSupplementalInfoSent();
1.560 +
1.561 + iSuppTime = EFalse;
1.562 + }
1.563 +
1.564 +void CMMFTestVideoEncodeHwDevice::GetOutputBufferStatus(TUint& aNumFreeBuffers, TUint& aTotalFreeBytes)
1.565 + {
1.566 + aNumFreeBuffers = KTestFreeBuffers;
1.567 + aTotalFreeBytes = KTestFreeBytes;
1.568 + }
1.569 +
1.570 +void CMMFTestVideoEncodeHwDevice::ReturnBuffer(TVideoOutputBuffer* /*aBuffer*/)
1.571 + {
1.572 + switch (iCurrentBuffer)
1.573 + {
1.574 + case 0:
1.575 + // Send two more buffers
1.576 + iCurrentBuffer = 1;
1.577 + iProxy->MdvrpNewBuffer(&(iDataBuffers[1]));
1.578 + iCurrentBuffer = 2;
1.579 + iProxy->MdvrpNewBuffer(&(iDataBuffers[2]));
1.580 + break;
1.581 + case 2:
1.582 + // Send three more buffers
1.583 + iCurrentBuffer = 3;
1.584 + iProxy->MdvrpNewBuffer(&(iDataBuffers[3]));
1.585 + iCurrentBuffer = 4;
1.586 + iProxy->MdvrpNewBuffer(&(iDataBuffers[4]));
1.587 + iCurrentBuffer = 5;
1.588 + iProxy->MdvrpNewBuffer(&(iDataBuffers[5]));
1.589 + break;
1.590 + case 5:
1.591 + // Send the rest of the buffers
1.592 + iCurrentBuffer = 6;
1.593 + iProxy->MdvrpNewBuffer(&(iDataBuffers[6]));
1.594 + iCurrentBuffer = 7;
1.595 + iProxy->MdvrpNewBuffer(&(iDataBuffers[7]));
1.596 + iCurrentBuffer = 8;
1.597 + iProxy->MdvrpNewBuffer(&(iDataBuffers[8]));
1.598 + iCurrentBuffer = 9;
1.599 + iProxy->MdvrpNewBuffer(&(iDataBuffers[9]));
1.600 + break;
1.601 + default:
1.602 + break;
1.603 + };
1.604 + }
1.605 +
1.606 +void CMMFTestVideoEncodeHwDevice::PictureLoss()
1.607 + {
1.608 + }
1.609 +
1.610 +void CMMFTestVideoEncodeHwDevice::PictureLoss(const TArray<TPictureId>& aPictures)
1.611 + {
1.612 + TBool success = EFalse;
1.613 +
1.614 + if (aPictures.Count() == 3)
1.615 + {
1.616 + if (ComparePictureIDs(aPictures[0], KTestPictureId1) &&
1.617 + ComparePictureIDs(aPictures[1], KTestPictureId2) &&
1.618 + ComparePictureIDs(aPictures[2], KTestPictureId3) )
1.619 + {
1.620 + success = ETrue;
1.621 + }
1.622 + }
1.623 +
1.624 + __ASSERT_ALWAYS(success, DevVideoEncoderPanic(EEncoderPanicPictureLossSpec));
1.625 + }
1.626 +
1.627 +void CMMFTestVideoEncodeHwDevice::SliceLoss(TUint aFirstMacroblock, TUint aNumMacroblocks, const TPictureId& aPicture)
1.628 + {
1.629 + __ASSERT_ALWAYS((aFirstMacroblock == KTestFirstMacroblock) &&
1.630 + (aNumMacroblocks == KTestNumMacroblocks) &&
1.631 + ComparePictureIDs(aPicture, KTestPictureId1), DevVideoEncoderPanic(EEncoderPanicSliceLoss));
1.632 + }
1.633 +
1.634 +void CMMFTestVideoEncodeHwDevice::ReferencePictureSelection(const TDesC8& aSelectionData)
1.635 + {
1.636 + __ASSERT_ALWAYS((aSelectionData == KTestRefPictureInfo), DevVideoEncoderPanic(EEncoderPanicRefPictureInfo));
1.637 + }
1.638 +
1.639 +void CMMFTestVideoEncodeHwDevice::CommitL()
1.640 + {
1.641 + }
1.642 +
1.643 +void CMMFTestVideoEncodeHwDevice::Revert()
1.644 + {
1.645 + }
1.646 +
1.647 +void CMMFTestVideoEncodeHwDevice::SetProxy(MMMFDevVideoRecordProxy& aProxy)
1.648 + {
1.649 + ASSERT(iProxy == NULL);
1.650 + iProxy = &aProxy;
1.651 + }
1.652 +