diff -r 000000000000 -r bde4ae8d615e os/mm/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayOne.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayOne.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,2133 @@ + +// 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: +// TestDevVideoPlay.cpp +// +// + +#include "TestDevVideoPlay.h" +#include "TestDevVideoPlayTestData.h" +#include "TestDevVideoPlugins/decoder.h" +#include "TestDevVideoPlugins/postproc.h" +#include + +const TInt KTestScreenCount = 2; +// DevVideoPlay base class + +const TUid KUidMDFVideoDecoderHwDeviceAdapter = { 0x102737ED }; + +CTestDevVideoPlayStep::CTestDevVideoPlayStep(const TDesC& aTestName, TTestType aTestType) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iTestType = aTestType; // included in case needed in future + } + +CTestDevVideoPlayStep::~CTestDevVideoPlayStep() + { + delete iDevVideoPlay; + } + +TVerdict CTestDevVideoPlayStep::DoTestStepL() + { + // construct DevVideoPlay object + __UHEAP_MARK; + TRAPD(err, iDevVideoPlay = CMMFDevVideoPlay::NewL(*this)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Could not create a CMMFDevVideoPlay class!")); + return EInconclusive; + } + + TVerdict ret = EFail; + + // call the test step + ret = DoTestL(*iDevVideoPlay); + + INFO_PRINTF1(_L("CMMFDevVideoPlay: Destroying")); + delete iDevVideoPlay; + iDevVideoPlay = NULL; + __MM_HEAP_MARKEND; + if(iError != KErrNone) + ERR_PRINTF2( _L("CMMFDevVideoPlay failed with error %d"), iError ); + + return ret; + } + + +// MMMFDevVideoPlayObserver +void CTestDevVideoPlayStep::MdvpoNewBuffers() + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoNewBuffers()")); + } + +void CTestDevVideoPlayStep::MdvpoReturnPicture(TVideoPicture* /*aPicture*/) + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoReturnPicture()")); + } + +void CTestDevVideoPlayStep::MdvpoSupplementalInformation(const TDesC8& /*aData*/, + const TTimeIntervalMicroSeconds& /*aTimestamp*/, + const TPictureId& /*aPictureId*/) + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoSupplementalInformation()")); + } + +void CTestDevVideoPlayStep::MdvpoPictureLoss() + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoPictureLoss()")); + } + +void CTestDevVideoPlayStep::MdvpoPictureLoss(const TArray& /*aPictures*/) + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoPictureLoss(TArray)")); + } + +void CTestDevVideoPlayStep::MdvpoSliceLoss(TUint /*aFirstMacroblock*/, TUint /*aNumMacroblocks*/, const TPictureId& /*aPicture*/) + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoSliceLoss()")); + } + +void CTestDevVideoPlayStep::MdvpoReferencePictureSelection(const TDesC8& /*aSelectionData*/) + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoReferencePictureSelection()")); + } + +void CTestDevVideoPlayStep::MdvpoTimedSnapshotComplete(TInt /*aError*/, + TPictureData* /*aPictureData*/, + const TTimeIntervalMicroSeconds& /*aPresentationTimestamp*/, + const TPictureId& /*aPictureId*/) + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoTimedSnapshotComplete()")); + } + +void CTestDevVideoPlayStep::MdvpoNewPictures() + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoNewPictures()")); + } + +void CTestDevVideoPlayStep::MdvpoFatalError(TInt aError) + { + iError = aError; + INFO_PRINTF2(_L("CTestDevVideoPlayStep::MdvpoFatalError(): Error = %d"), aError); + } + +void CTestDevVideoPlayStep::MdvpoInitComplete(TInt aError) + { + iError = aError; + INFO_PRINTF2(_L("CTestDevVideoPlayStep::MdvpoInitComplete(): Error = %d"), aError); + } + +void CTestDevVideoPlayStep::MdvpoStreamEnd() + { + INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoStreamEnd()")); + } + +//------------------------------------------------------------------ + +CTestDevVideoPlayCommonFormat::CTestDevVideoPlayCommonFormat(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayCommonFormat* CTestDevVideoPlayCommonFormat::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayCommonFormat* self = new(ELeave) CTestDevVideoPlayCommonFormat(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayCommonFormat::DoTestL(CMMFDevVideoPlay& /*aDevVideoPlay*/) + { + TVerdict ret = EPass; + TBool expErr = ETrue; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: Find common format")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // make a fake list of formats + RArray vFormats1; + RArray vFormats2; + + TUncompressedVideoFormat commonFormat; + TUncompressedVideoFormat otherFormat; + + // push arrays to cleanup stack + CleanupClosePushL(vFormats1); + CleanupClosePushL(vFormats2); + + // setup vFormats1 + User::LeaveIfError(vFormats1.Append(KTestVidFormat1)); + User::LeaveIfError(vFormats1.Append(KTestVidFormat2)); + + // setup vFormats2 + User::LeaveIfError(vFormats2.Append(KTestVidFormat2)); + User::LeaveIfError(vFormats2.Append(KTestVidFormat3)); + + TArray t1 = vFormats1.Array(); + TArray t2 = vFormats2.Array(); + TBool formatFound = EFalse; + + // attempt to find a common format + formatFound = CMMFDevVideoPlay::FindCommonFormat(t1, t2, commonFormat); + + // now attempt to find a common format that doesn't exist + vFormats1.Reset(); + User::LeaveIfError(vFormats1.Append(KTestVidFormat1)); + User::LeaveIfError(vFormats1.Append(KTestVidFormat1)); + TBool otherFormatFound = ETrue; + + // perform search for non-existent common format + t1 = vFormats1.Array(); // need to get Array class again + otherFormatFound = CMMFDevVideoPlay::FindCommonFormat(t1, t2, otherFormat); + + // close the arrays + CleanupStack::PopAndDestroy(2, &vFormats1); + + // check format + if ( (!formatFound) || !(commonFormat == KTestVidFormat2) ) + { + ret = EFail; + ERR_PRINTF1(_L("Error: No common format found...")); + } + else if (otherFormatFound ) + { + ret = EFail; + ERR_PRINTF1(_L("Error: Found a common format when there wasn't one!")); + } + else + { + INFO_PRINTF3(_L("FindCommonFormat(), %d = %d"), formatFound, expErr); + } + return ret; + } + + +//------------------------------------------------------------------ + + + +//------------------------------------------------------------------ + +CTestDevVideoPlayFindDecoders::CTestDevVideoPlayFindDecoders(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayFindDecoders* CTestDevVideoPlayFindDecoders::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayFindDecoders* self = new(ELeave) CTestDevVideoPlayFindDecoders(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayFindDecoders::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EFail; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: FindDecoders")); + + RArray foundDecoders; + CleanupClosePushL(foundDecoders); + RArray expectedDecoders; + CleanupClosePushL(expectedDecoders); + RArray unExpectedDecoders; + CleanupClosePushL(unExpectedDecoders); + + TInt error = KErrNone; + TUint32 requestedPostProcType = 0; + + // Unsupported mime type + if (!error) + { + requestedPostProcType = 0; + _LIT8(KMimeType1, "VIDEO/mpeg21"); + foundDecoders.Reset(); + expectedDecoders.Reset(); + unExpectedDecoders.Reset(); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5)); + + TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType1(), requestedPostProcType, foundDecoders, EFalse)); + + if (!error) + error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders); + } + + // Unsupported post proc type + if (!error) + { + requestedPostProcType = EPpOutputCrop|EPpInputCrop; + foundDecoders.Reset(); + _LIT8(KMimeType2, "videO/duMMy"); + expectedDecoders.Reset(); + unExpectedDecoders.Reset(); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5)); + + TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType2(), requestedPostProcType, foundDecoders, EFalse)); + if (error == KErrNotFound)//we actually expect KErrNotFound here + error = KErrNone; + else + error = KErrGeneral; + + if (!error) + error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders); + } + + // Unsupported mime type (by exact match) + if (!error) + { + _LIT8(KMimeType3, "video/H263-2000; profile=45;level=40"); + requestedPostProcType = 0; + foundDecoders.Reset(); + expectedDecoders.Reset(); + unExpectedDecoders.Reset(); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5)); + + TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType3(), requestedPostProcType, foundDecoders, ETrue)); + if (error == KErrNotFound)//we actually expect KErrNotFound here + error = KErrNone; + else + error = KErrGeneral; + + if (!error) + error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders); + } + + // Supported mime type (by unexact match) + if (!error) + { + _LIT8(KMimeType4, "video/H263-2000; profile=1234;level=20"); + requestedPostProcType = 0; + foundDecoders.Reset(); + expectedDecoders.Reset(); + unExpectedDecoders.Reset(); + User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4)); + User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5)); + + TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType4(), requestedPostProcType, foundDecoders, EFalse)); + + if (!error) + error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders); + } + + // Supported mime type and post proc type (by exact match) + if (!error) + { + _LIT8(KMimeType5, "video/zippyvideo"); + requestedPostProcType = EPpMirror|EPpInputCrop; + foundDecoders.Reset(); + expectedDecoders.Reset(); + unExpectedDecoders.Reset(); + User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5)); + + TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType5(), requestedPostProcType, foundDecoders, ETrue)); + + if (!error) + error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders); + } + + //Added to check that the mimetype comparison is not case sensitive + if (!error) + { + _LIT8(KMimeType6, "VIDEO/ZIPPYvideo"); + requestedPostProcType = EPpMirror|EPpInputCrop; + foundDecoders.Reset(); + expectedDecoders.Reset(); + unExpectedDecoders.Reset(); + User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4)); + User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5)); + + INFO_PRINTF1(_L("To check that the mime type comparison is not case sensitive")); + TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType6(), requestedPostProcType, foundDecoders, ETrue)); + INFO_PRINTF2(_L("error = %d"),error); + if (!error) + error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders); + + } + + CleanupStack::PopAndDestroy(3); //foundDecoders, expectedDecoders, unExpectedDecoders + + if (!error) + ret = EPass; + + return ret; + } + +TInt CTestDevVideoPlayFindDecoders::CheckDecoders(const RArray& aFoundDecoders, + const RArray& aExpectedDecoders, + const RArray& aUnExpectedDecoders) + { + TInt ret = KErrGeneral; + + TBool foundUnExpected = EFalse; + TInt numberToBeFoundInExpectedDecoders = aExpectedDecoders.Count(); + + for (TInt i=0; i foundPostProx; + CleanupClosePushL(foundPostProx); + RArray expectedPostProx; + CleanupClosePushL(expectedPostProx); + RArray unExpectedPostProx; + CleanupClosePushL(unExpectedPostProx); + + TInt error = KErrNone; + TUint32 requestedPostProcType = 0; + + // First ask for post processor isn't supported + if (!error) + { + requestedPostProcType = EPpInputCrop|EPpMirror|EPpScale|EPpOutputPad|EPpNoiseFilter; + foundPostProx.Reset(); + expectedPostProx.Reset(); + unExpectedPostProx.Reset(); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1)); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2)); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3)); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4)); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5)); + + TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx)); + if (error == KErrNotFound)//we actually expect KErrNotFound here + error = KErrNone; + else + error = KErrGeneral; + + if (!error) + error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx); + } + + // Next ask for all post processors + if (!error) + { + requestedPostProcType = 0; + foundPostProx.Reset(); + expectedPostProx.Reset(); + unExpectedPostProx.Reset(); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5)); + + TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx)); + if (!error) + error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx); + } + + // Next ask for a specific subset of post processors + if (!error) + { + requestedPostProcType = EPpMirror; + foundPostProx.Reset(); + expectedPostProx.Reset(); + unExpectedPostProx.Reset(); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2)); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4)); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5)); + + TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx)); + if (!error) + error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx); + } + + // Next ask for another specific subset of post processors + if (!error) + { + requestedPostProcType = EPpMirror|EPpInputCrop; + foundPostProx.Reset(); + expectedPostProx.Reset(); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2)); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3)); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4)); + User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5)); + + TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx)); + if (!error) + error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx); + } + + CleanupStack::PopAndDestroy(3);//foundPostProx, expectedPostProx, unExpectedPostProx + + if (!error) + ret = EPass; + + return ret; + } + + +TInt CTestDevVideoPlayFindPostProc::CheckPostProx(const RArray& aFoundPostProx, + const RArray& aExpectedPostProx, + const RArray& aUnExpectedPostProx) + { + TInt ret = KErrGeneral; + + TBool foundUnExpected = EFalse; + TInt numberToBeFoundInExpectedPostProx = aExpectedPostProx.Count(); + + for (TInt i=0; i foundDecoders; + CleanupClosePushL(foundDecoders); + RArray expectedDecoders; + CleanupClosePushL(expectedDecoders); + + User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1)); + User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2)); + User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3)); + User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4)); + User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5)); + + TRAPD(err, aDevVideoPlay.GetDecoderListL(foundDecoders)); + + if (!err) + { + // Make sure that the video hardware device adapter is NOT in the array + TBool foundAdapter = EFalse; + for (TInt j = 0; j < foundDecoders.Count(); j++) + { + if (foundDecoders[j] == KUidMDFVideoDecoderHwDeviceAdapter) + { + foundAdapter = ETrue; + break; + } + } + + // Make sure that all the UIDs of the test plugins are in the array.. + TInt numberToBeFound = expectedDecoders.Count(); + for (TInt i=0; i foundPostProx; + CleanupClosePushL(foundPostProx); + RArray expectedPostProx; + CleanupClosePushL(expectedPostProx); + + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4)); + User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5)); + + TRAPD(err, aDevVideoPlay.GetPostProcessorListL(foundPostProx)); + + if (!err) + { + // Make sure that all the UIDs of the test plugins are in the array.. + TInt numberToBeFound = expectedPostProx.Count(); + for (TInt i=0; iUid() != KUidDevVideoTestDecodeHwDevice) + { + ERR_PRINTF1(_L("Error - Decoder UID is incorrect!")); + ret = EFalse; + } + // Manufacturer check + if (!(aInfo->Manufacturer() == KTestDecoderInfoManufacturer)) + { + ERR_PRINTF1(_L("Error - Manufacturer is incorrect!")); + ret = EFalse; + } + // Identifier check + if (!(aInfo->Identifier() == KTestDecoderInfoIdentifier)) + { + ERR_PRINTF1(_L("Error - Identifier is incorrect!")); + ret = EFalse; + } + // Version check + TVersion decVer = aInfo->Version(); + if ( (decVer.iMajor != KTestDecoderInfoVersionMaj) || + (decVer.iMinor != KTestDecoderInfoVersionMin) || + (decVer.iBuild != KTestDecoderInfoVersionBuild) ) + { + ERR_PRINTF1(_L("Error - Version is incorrect!")); + ret = EFalse; + } + // Accelerated check + if (!aInfo->Accelerated()) + { + ERR_PRINTF1(_L("Error - Accelerated = EFalse!")); + ret = EFalse; + } + // Direct display check + if (!aInfo->SupportsDirectDisplay()) + { + ERR_PRINTF1(_L("Error - Supports Direct Display = EFalse!")); + ret = EFalse; + } + + // Max picture size + TSize maxSize = aInfo->MaxPictureSize(); + if (maxSize.iWidth != KTestDecoderInfoMaxSizeX || maxSize.iHeight != KTestDecoderInfoMaxSizeY) + { + ERR_PRINTF1(_L("Error - Max Picture Size is wrong!")); + ret = EFalse; + } + + // Max Bitrate + if (aInfo->MaxBitrate() != KMaxTUint) + { + ERR_PRINTF1(_L("Error - Max Bitrate is wrong!")); + ret = EFalse; + } + + // Supports picture loss + if (!aInfo->SupportsPictureLoss()) + { + ERR_PRINTF1(_L("Error - Supports Picture Loss = EFalse!")); + ret = EFalse; + } + + // Supports slice loss + if (aInfo->SupportsSliceLoss()) + { + ERR_PRINTF1(_L("Error - Supports Slice Loss = ETrue!")); + ret = EFalse; + } + + // Coding standard info + if (!(aInfo->CodingStandardSpecificInfo() == KTestDecoderInfoCSInfo)) + { + ERR_PRINTF1(_L("Error - Coding standard specific info is incorrect!")); + ret = EFalse; + } + // Implementation info + if (!(aInfo->ImplementationSpecificInfo() == KTestDecoderInfoISInfo)) + { + ERR_PRINTF1(_L("Error - Implementation specific info is incorrect!")); + ret = EFalse; + } + + if (!aInfo->SupportsContentProtected())//Check if flag is set indicating Content Protection is supported. + { + ERR_PRINTF1(_L("Error - Failed To get flag indicating support of Content Protection!")); + ret = EFalse; + } + + // get some test compressed video formats + CCompressedVideoFormat* testFormat = NULL; + TInt err = KErrNone; + + // get formats supported + const RPointerArray& vidFormats = aInfo->SupportedFormats(); + + // get supported max picture rates + TPictureRateAndSize testRate; + const RArray& maxRates = aInfo->MaxPictureRates(); + + // test formats supported + for (TUint i = 0; i < KTestDecoderInfoCount; i++) + { + TPtrC8 mimeType = KTestDecoderInfoMimeArray[i]; + TRAP(err, testFormat = GetTestCVFormatL(mimeType)); + if (err != KErrNone) + { + ERR_PRINTF2(_L("Error - Failed to construct CCompressedVideoFormat: %d!"), i); + ret = EFalse; + if(testFormat != NULL) + { + delete testFormat; + testFormat=NULL; + } + break; + } + + if (!(*testFormat == *(vidFormats[i])) || !(aInfo->SupportsFormat(*testFormat))) + { + ERR_PRINTF2(_L("Error - Video Format %d is corrupt!"), i); + ret = EFalse; + } + + delete testFormat; + testFormat = NULL; + + // Test supported max picture rates + GetTestEncoderInfoRate(i, testRate); + if (!(testRate.iPictureSize == maxRates[i].iPictureSize) || + !(testRate.iPictureRate == maxRates[i].iPictureRate) ) + { + ERR_PRINTF2(_L("Error - picture rate %d is corrupt!"), i); + ret = EFalse; + } + } + //Screen information check +#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT + RArray supportedScreens; + TRAP(err, aInfo->GetSupportedScreensL(supportedScreens)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("GetSupportedScreensL leaves with %d"), err); + ret = EFalse; + } + if(supportedScreens.Count() != KTestScreenCount) + { + ERR_PRINTF1(_L("Error - Unexpected screen count")); + ret = EFalse; + } + err = supportedScreens.Find(KDecoderDefaultScreenNumber); + if(err == KErrNotFound) + { + ERR_PRINTF1(_L("Error - No support for primary screen")); + ret = EFalse; + } + err = supportedScreens.Find(KDecoderSecondaryScreenNumber); + if(err == KErrNotFound) + { + ERR_PRINTF1(_L("Error - No support for secondary screen")); + ret = EFalse; + } + supportedScreens.Close(); +#endif + // finally check a format which isn't supposed to be supported + TRAP(err, testFormat = GetTestCVFormatL(_L8("Frederick Bloggs and his amazing coloured dog"))); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - Failed to construct final CCompressedVideoFormat!")); + ret = EFalse; + } + else + { + if (aInfo->SupportsFormat(*testFormat)) + { + ERR_PRINTF1(_L("Error - Failed negative SupportsFormat() check!")); + ret = EFalse; + } + } + + if(testFormat != NULL) + { + delete testFormat; + testFormat=NULL; + } + return ret; + } + +TVerdict CTestDevVideoPlayGetDecoderInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetDecoderInfo")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + CVideoDecoderInfo *decInfo = NULL; + TBool valid = EFalse; + + // get decoder information from test decoder plugin + + TRAP(err, + decInfo = aDevVideoPlay.VideoDecoderInfoLC(KUidDevVideoTestDecodeHwDevice); + valid = ValidDecoderInfo(decInfo); + CleanupStack::PopAndDestroy(decInfo); ); + if (err != expErr) + { + ERR_PRINTF3(_L("VideoDecoderInfoLC() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + // check the Video Decoder + else if (!valid) + { + ERR_PRINTF1(_L("CVideoDecoderInfo class is corrupt!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("CVideoDecoderInfo passed check successfully")); + INFO_PRINTF3(_L("VideoDecoderInfoLC(), %d = %d"), err, expErr); + } + + return ret; + } + + + + +//------------------------------------------------------------------ + +CTestDevVideoPlayGetPostProcInfo::CTestDevVideoPlayGetPostProcInfo(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayGetPostProcInfo* CTestDevVideoPlayGetPostProcInfo::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayGetPostProcInfo* self = new(ELeave) CTestDevVideoPlayGetPostProcInfo(aTestName, aTestType); + return self; + } + +TBool CTestDevVideoPlayGetPostProcInfo::ValidPostProcInfo(CPostProcessorInfo* aInfo) + { + // do null pointer check + if (!aInfo) + { + ERR_PRINTF1(_L("Error - Post Processor Info is NULL!")); + return EFalse; + } + + // check the post processor against test data + // need to check every call so as to keep code coverage + // and prevent a situation where if the first test fails + // then subsequent tests will not be called + TBool ret = ETrue; + + // UID check + if (aInfo->Uid() != KUidDevVideoTestPostProcHwDevice) + { + ERR_PRINTF1(_L("Error - Post Processor UID is incorrect!")); + ret = EFalse; + } + // Manufacturer check + if (!(aInfo->Manufacturer() == KTestPostProcInfoManufacturer)) + { + ERR_PRINTF1(_L("Error - Manufacturer is incorrect!")); + ret = EFalse; + } + // Identifier check + if (!(aInfo->Identifier() == KTestPostProcInfoIdentifier)) + { + ERR_PRINTF1(_L("Error - Identifier is incorrect!")); + ret = EFalse; + } + // Version check + TVersion posVer = aInfo->Version(); + if ( (posVer.iMajor != KTestPostProcInfoVersionMaj) || + (posVer.iMinor != KTestPostProcInfoVersionMin) || + (posVer.iBuild != KTestPostProcInfoVersionBuild) ) + { + ERR_PRINTF1(_L("Error - Version is incorrect!")); + ret = EFalse; + } + // Accelerated check + if (!aInfo->Accelerated()) + { + ERR_PRINTF1(_L("Error - Accelerated = EFalse!")); + ret = EFalse; + } + // Direct display check + if (!aInfo->SupportsDirectDisplay()) + { + ERR_PRINTF1(_L("Error - Supports Direct Display = EFalse!")); + ret = EFalse; + } + // YUVToRGB Capabilities + if (!CompareYuvRgbCaps(aInfo->YuvToRgbCapabilities(), KTestPostProcInfoYuvToRgbCaps)) + { + ERR_PRINTF1(_L("Error - YUV To RGB capabilities is incorrect!")); + ret = EFalse; + } + + // Supported rotations + if (aInfo->SupportedRotations() != KTestPostProcInfoRotations) + { + ERR_PRINTF1(_L("Error - Supported Rotations is incorrect!")); + ret = EFalse; + } + + // Supports arbitrary scaling check + if (!aInfo->AntiAliasedScaling()) + { + ERR_PRINTF1(_L("Error - Anti-Aliased Scaling = EFalse!")); + ret = EFalse; + } + // Supports anti-aliased scaling check + if (!aInfo->SupportsArbitraryScaling()) + { + ERR_PRINTF1(_L("Error - Supports Arbitrary Scaling = EFalse!")); + ret = EFalse; + } + // Implementation info + if (!(aInfo->ImplementationSpecificInfo() == KTestPostProcInfoISInfo)) + { + ERR_PRINTF1(_L("Error - Implementation specific info is incorrect!")); + ret = EFalse; + } + + // get some test compressed video formats + TUncompressedVideoFormat testFormat; + TUint32 testComb = 0; + TScaleFactor testFactor = {0, 0}; + + // get supported formats + const RArray& vidFormats = aInfo->SupportedFormats(); + + // get supported combinations + const RArray& suppCombs = aInfo->SupportedCombinations(); + + // get supported scale factors + const RArray& scaleFactors = aInfo->SupportedScaleFactors(); + + // test formats, combinations, and scale factors supported + for (TUint i = 0; i < KTestPostProcInfoCount; i++) + { + testFormat = KTestPostProcInfoFormatArray[i]; + if (!(testFormat == (vidFormats[i])) || !(aInfo->SupportsFormat(testFormat))) + { + ERR_PRINTF2(_L("Error - Video Format %d is corrupt!"), i); + ret = EFalse; + } + + testComb = KTestPostProcInfoCombsArray[i]; + if (!(testComb == (suppCombs[i])) || !(aInfo->SupportsCombination(testComb))) + { + ERR_PRINTF2(_L("Error - Combination %d is corrupt!"), i); + ret = EFalse; + } + + testFactor = KTestPostProcInfoScaleFactorsArray[i]; + if (!CompareScaleFactors(testFactor, scaleFactors[i])) + { + ERR_PRINTF2(_L("Error - Scale factor %d is corrupt!"), i); + ret = EFalse; + } + } + + //Screen information check +#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT + RArray supportedScreens; + TRAPD(err, aInfo->GetSupportedScreensL(supportedScreens)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("GetSupportedScreensL leaves with %d"), err); + ret = EFalse; + } + if(supportedScreens.Count() != KTestScreenCount) + { + ERR_PRINTF1(_L("Error - Unexpected screen count")); + ret = EFalse; + } + err = supportedScreens.Find(KPostProcDefaultScreenNumber); + if(err == KErrNotFound) + { + ERR_PRINTF1(_L("Error - No support for primary screen")); + ret = EFalse; + } + err = supportedScreens.Find(KPostProcSecondaryScreenNumber); + if(err == KErrNotFound) + { + ERR_PRINTF1(_L("Error - No support for secondary screen")); + ret = EFalse; + } + supportedScreens.Close(); +#endif + // check a format that isn't supposed to be supported + testFormat = KTestPostProcInfoNegativeFormat; + testFormat.iYuvFormat = KTestYuvFormat1; + if (aInfo->SupportsFormat(testFormat)) + { + ERR_PRINTF1(_L("Error - Failed negative SupportsFormat() check!")); + ret = EFalse; + } + + // finally check a combination that isn't supposed to be supported + testComb = KTestPostProcInfoNegativeComb; + if (aInfo->SupportsCombination(testComb)) + { + ERR_PRINTF1(_L("Error - Failed negative SupportsCombination() check!")); + ret = EFalse; + } + + if (!aInfo->SupportsContentProtected())//Check if flah is set indicating Content Protection is supported. + { + ERR_PRINTF1(_L("Error - Failed To get flag indicating support of Content Protection!")); + ret = EFalse; + } + + return ret; + } + +TVerdict CTestDevVideoPlayGetPostProcInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetPostProcInfo")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + CPostProcessorInfo *procInfo = NULL; + TBool valid = EFalse; + + // get decoder information from test decoder plugin + TRAP(err, + procInfo = aDevVideoPlay.PostProcessorInfoLC(KUidDevVideoTestPostProcHwDevice); + procInfo->SetSupportsContentProtected(ETrue); + valid = ValidPostProcInfo(procInfo); + CleanupStack::PopAndDestroy(procInfo); ); + + if (err != expErr) + { + ERR_PRINTF3(_L("PostProcessorInfoLC() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + // check the Video Post Processor + else if (!valid) + { + ERR_PRINTF1(_L("CPostProcessorInfo class is corrupt!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("CPostProcessorInfo passed check successfully")); + INFO_PRINTF3(_L("PostProcessorInfoLC(), %d = %d"), err, expErr); + } + + return ret; + } + +//------------------------------------------------------------------ + +CTestDevVideoPlaySelectDecoder::CTestDevVideoPlaySelectDecoder(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySelectDecoder* CTestDevVideoPlaySelectDecoder::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySelectDecoder* self = new(ELeave) CTestDevVideoPlaySelectDecoder(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySelectDecoder::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SelectDecoder")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + iError = KErrNone; + + // this will leave if an error occurs + TRAP( iError, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice) ); + + if (iError != expErr) + { + ERR_PRINTF3(_L("SelectDecoderL() gave error %d (expected %d)"),iError, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SelectDecoderL(), %d = %d"), iError, expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestDevVideoPlaySelectPostProc::CTestDevVideoPlaySelectPostProc(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySelectPostProc* CTestDevVideoPlaySelectPostProc::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySelectPostProc* self = new(ELeave) CTestDevVideoPlaySelectPostProc(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySelectPostProc::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SelectPostProc")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + iError = KErrNone; + + // this will leave if an error occurs + TRAP( iError, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice) ); + + if (iError != expErr) + { + ERR_PRINTF3(_L("SelectPostProcessorL() gave error %d (expected %d)"),iError, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SelectPostProcessorL(), %d = %d"), iError, expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestDevVideoPlayGetHeaderInfo::CTestDevVideoPlayGetHeaderInfo(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayGetHeaderInfo* CTestDevVideoPlayGetHeaderInfo::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayGetHeaderInfo* self = new(ELeave) CTestDevVideoPlayGetHeaderInfo(aTestName, aTestType); + return self; + } + +TBool CTestDevVideoPlayGetHeaderInfo::ValidPictureHeader(const TVideoPictureHeader* aPictureHeader) + { + TBool ret = EFalse; + + if (!aPictureHeader) + { + ERR_PRINTF1(_L("Error - Picture Header is NULL!")); + return EFalse; + } + + TTimeIntervalMicroSeconds testTime(KTestInputBufferTimestamp); + + // check the picture header + if (aPictureHeader->iOptions != KTestPictureHeaderOptions) + { + ERR_PRINTF1(_L("Error - Options are incorrect!")); + } + + else if (!(aPictureHeader->iPresentationTimestamp == testTime)) + { + ERR_PRINTF1(_L("Error - Timestamp is incorrect!")); + } + else if (!(*(aPictureHeader->iOptional) == KTestInputBufferData())) + { + ERR_PRINTF1(_L("Error - Optional data is corrupt!")); + } + else + { + INFO_PRINTF1(_L("Picture Header is valid")); + ret = ETrue; + } + + return ret; + } + +TVerdict CTestDevVideoPlayGetHeaderInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetHeaderInfo")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; +// THwDeviceId hwDecoder = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // construct a test video input buffer with a valid timestamp + TPtrC8 testInputBufferDataLitCPtr(KTestInputBufferData); + HBufC8* testInputBufferData = testInputBufferDataLitCPtr.AllocLC(); + + TVideoInputBuffer testBuffer; + testBuffer.iOptions = KTestInputBufferOptions; + testBuffer.iPresentationTimestamp = KTestInputBufferTimestamp; + testBuffer.iData.Set(testInputBufferData->Des()); + + TVideoPictureHeader* picHeader = NULL; + // get header information from test data unit + TRAP(err, picHeader = aDevVideoPlay.GetHeaderInformationL(KTestDataUnitType, KTestDataUnitEncap, &testBuffer) ); + + if (err != expErr) + { + ERR_PRINTF3(_L("GetHeaderInformationL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else if (!ValidPictureHeader(picHeader)) + { + ERR_PRINTF1(_L("Picture header corrupt!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("Header information retrieved successfully")); + INFO_PRINTF3(_L("GetHeaderInformationL(), %d = %d"), err, expErr); + } + + CleanupStack::PopAndDestroy(testInputBufferData); + + return ret; + } + +//------------------------------------------------------------------ + +CTestDevVideoPlayReturnHeader::CTestDevVideoPlayReturnHeader(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayReturnHeader* CTestDevVideoPlayReturnHeader::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayReturnHeader* self = new(ELeave) CTestDevVideoPlayReturnHeader(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayReturnHeader::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: ReturnHeader")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; +// THwDeviceId hwDecoder = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + TVideoPictureHeader picHeader; + picHeader.iOptions = KTestPictureHeaderOptions; + TTimeIntervalMicroSeconds testTime(KTestPictureHeaderTimestamp); + picHeader.iPresentationTimestamp = testTime; + + // return picture header [can use a local TVideoPictureHeader because we + // are testing a fake plugin - normally this would be a header supplied by + // the video plugin]. + aDevVideoPlay.ReturnHeader(&picHeader); + + // if plugin didn't PANIC then test has passed + INFO_PRINTF1(_L("Header information returned successfully")); + + return ret; + } + +//------------------------------------------------------------------ + +CTestDevVideoPlayConfigureDecoder::CTestDevVideoPlayConfigureDecoder(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayConfigureDecoder* CTestDevVideoPlayConfigureDecoder::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayConfigureDecoder* self = new(ELeave) CTestDevVideoPlayConfigureDecoder(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayConfigureDecoder::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr; + + expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: ConfigureDecoderL")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + //construct a test picture header + TVideoPictureHeader pictureHeader; + pictureHeader.iOptions = KTestPictureHeaderOptions; + pictureHeader.iPresentationTimestamp = KTestInputBufferTimestamp; + + TPtrC8 testInputBufferDataLitCPtr(KTestInputBufferData); + pictureHeader.iOptional = &testInputBufferDataLitCPtr; + + // get header information from test data unit + TRAP(err, aDevVideoPlay.ConfigureDecoderL(pictureHeader)); + + if (err != expErr) + { + ERR_PRINTF3(_L("ConfigureDecoderL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + { + if (err == KErrNone) + { + INFO_PRINTF1(_L("Header information successfully configured in Decoder")); + } + INFO_PRINTF3(_L("ConfigureDecoderL(), error %d = expected %d"), err, expErr); + } + + return ret; + } + +//------------------------------------------------------------------ + +CTestDevVideoPlaySetInputFormatUC::CTestDevVideoPlaySetInputFormatUC(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetInputFormatUC* CTestDevVideoPlaySetInputFormatUC::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetInputFormatUC* self = new(ELeave) CTestDevVideoPlaySetInputFormatUC(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetInputFormatUC::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetInputFormatUC")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; + THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // this will leave if an error occurs in either plugin + TRAP(err, aDevVideoPlay.SetInputFormatL(hwPostProc, KTestVidFormat2) ); + + if ( err != expErr ) + { + ERR_PRINTF3(_L("SetInputFormatL() on Post-Processor gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetInputFormat(), %d = %d"), err, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetInputFormat::CTestDevVideoPlaySetInputFormat(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetInputFormat* CTestDevVideoPlaySetInputFormat::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetInputFormat* self = new(ELeave) CTestDevVideoPlaySetInputFormat(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetInputFormat::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetInputFormat")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + + THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // get a temporary compressed video class + CCompressedVideoFormat *tempCFormat = NULL; + TRAP(err, tempCFormat = GetTestCVFormatL(KTestMimeType1)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize compressed video class")); + return EInconclusive; + } + + // this will leave if an error occurs + TRAP(err, aDevVideoPlay.SetInputFormatL(hwDecoder, *tempCFormat, KTestUnitType1, KTestEncapType1, ETrue) ); + + // delete compressed video class + delete tempCFormat; + tempCFormat = NULL; + + if ( err != expErr ) + { + ERR_PRINTF3(_L("SetInputFormatL() on Decoder gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetInputFormat(), %d = %d"), err, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlayGetOutputFormatList::CTestDevVideoPlayGetOutputFormatList(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayGetOutputFormatList* CTestDevVideoPlayGetOutputFormatList::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayGetOutputFormatList* self = new(ELeave) CTestDevVideoPlayGetOutputFormatList(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayGetOutputFormatList::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetOutputFormatList")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = KErrNone; + + THwDeviceId hwDecoder = 0; + THwDeviceId hwPostProc = 0; + + // select decoder + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + RArray decodeList; + RArray postProcList; + + // Get output format list for decoder + TRAP(err, aDevVideoPlay.GetOutputFormatListL(hwDecoder, decodeList)); + + // Get output format list for post-processor + TRAP(err2, aDevVideoPlay.GetOutputFormatListL(hwPostProc, postProcList)); + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("GetOutputFormatListL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("GetOutputFormatListL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + { + TBool decPass = EFalse; + TBool posPass = EFalse; + + // expecting KTestVidFormat1,2,3 - check + TInt count = decodeList.Count(); + if (count == 3) + { + if ((decodeList[0] == KTestVidFormat1) && + (decodeList[1] == KTestVidFormat2) && + (decodeList[2] == KTestVidFormat3) ) + { + INFO_PRINTF1(_L("Decoder output list checks ok")); + decPass = ETrue; + } + } + + // expecting KTestVidFormat3,2,1 - check + count = postProcList.Count(); + if (count == 3) + { + if ((postProcList[0] == KTestVidFormat3) && + (postProcList[1] == KTestVidFormat2) && + (postProcList[2] == KTestVidFormat1) ) + { + INFO_PRINTF1(_L("Post-Processor output list checks ok")); + posPass = ETrue; + } + } + + if (!decPass) + { + ERR_PRINTF1(_L("Decoder output list corrupt!")); + ret = EFail; + } + + if (!posPass) + { + ERR_PRINTF1(_L("Post-Processor output list corrupt!")); + ret = EFail; + } + + INFO_PRINTF4(_L("GetOutputFormatListL(), %d, %d = %d"), err, err2, expErr); + } + + // close the arrays + decodeList.Reset(); + decodeList.Close(); + + postProcList.Reset(); + postProcList.Close(); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetOutputFormat::CTestDevVideoPlaySetOutputFormat(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetOutputFormat* CTestDevVideoPlaySetOutputFormat::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetOutputFormat* self = new(ELeave) CTestDevVideoPlaySetOutputFormat(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetOutputFormat::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetOutputFormat")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = KErrNone; + + THwDeviceId hwDecoder = 0; + THwDeviceId hwPostProc = 0; + + // select decoder + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // set output format on decoder + TRAP(err, aDevVideoPlay.SetOutputFormatL(hwDecoder, KTestVidFormat1) ) + + // set output format on post-processor + TRAP(err2, aDevVideoPlay.SetOutputFormatL(hwPostProc, KTestVidFormat2) ) + + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("SetOutputFormatL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("SetOutputFormatL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF4(_L("SetOutputFormat(), %d, %d= %d"), err, err2, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetPostProcTypes::CTestDevVideoPlaySetPostProcTypes(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetPostProcTypes* CTestDevVideoPlaySetPostProcTypes::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetPostProcTypes* self = new(ELeave) CTestDevVideoPlaySetPostProcTypes(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetPostProcTypes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetPostProcTypes")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = KErrNone; + + THwDeviceId hwDecoder = 0; + THwDeviceId hwPostProc = 0; + + // select decoder + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // set post-process types on decoder + TRAP(err, aDevVideoPlay.SetPostProcessTypesL(hwDecoder, KTestProcessType1) ) + + // set post-process types on post-processor + TRAP(err2, aDevVideoPlay.SetPostProcessTypesL(hwPostProc, KTestProcessType2) ) + + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("SetPostProcessTypesL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("SetPostProcessTypesL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF4(_L("SetPostProcessTypes(), %d, %d= %d"), err, err2, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlayGetDecoderPostProcInfo::CTestDevVideoPlayGetDecoderPostProcInfo(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayGetDecoderPostProcInfo* CTestDevVideoPlayGetDecoderPostProcInfo::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayGetDecoderPostProcInfo* self = new(ELeave) CTestDevVideoPlayGetDecoderPostProcInfo(aTestName, aTestType); + return self; + } + +TBool CTestDevVideoPlayGetDecoderPostProcInfo::ValidPostProcInfo(CPostProcessorInfo* aInfo) + { + // do null pointer check + if (!aInfo) + { + ERR_PRINTF1(_L("Error - Post Processor Info is NULL!")); + return EFalse; + } + + // check the post processor against test data + // need to check every call so as to keep code coverage + // and prevent a situation where if the first test fails + // then subsequent tests will not be called + TBool ret = ETrue; + + // UID check + if (aInfo->Uid() != KUidDevVideoTestDecodeHwDevice) + { + ERR_PRINTF1(_L("Error - Decoder UID is incorrect!")); + ret = EFalse; + } + // Manufacturer check + if (!(aInfo->Manufacturer() == KTestPostProcInfoManufacturer)) + { + ERR_PRINTF1(_L("Error - Manufacturer is incorrect!")); + ret = EFalse; + } + // Identifier check + if (!(aInfo->Identifier() == KTestPostProcInfoIdentifier)) + { + ERR_PRINTF1(_L("Error - Identifier is incorrect!")); + ret = EFalse; + } + // Version check + TVersion posVer = aInfo->Version(); + if ( (posVer.iMajor != KTestPostProcInfoVersionMaj) || + (posVer.iMinor != KTestPostProcInfoVersionMin) || + (posVer.iBuild != KTestPostProcInfoVersionBuild) ) + { + ERR_PRINTF1(_L("Error - Version is incorrect!")); + ret = EFalse; + } + // Accelerated check + if (!aInfo->Accelerated()) + { + ERR_PRINTF1(_L("Error - Accelerated = EFalse!")); + ret = EFalse; + } + // Direct display check + if (!aInfo->SupportsDirectDisplay()) + { + ERR_PRINTF1(_L("Error - Supports Direct Display = EFalse!")); + ret = EFalse; + } + // YUVToRGB Capabilities + if (!CompareYuvRgbCaps(aInfo->YuvToRgbCapabilities(), KTestPostProcInfoYuvToRgbCaps)) + { + ERR_PRINTF1(_L("Error - YUV To RGB capabilities is incorrect!")); + ret = EFalse; + } + //Content Protection + if (!aInfo->SupportsContentProtected())//Check if flag is set indicating Content Protection is supported. + { + ERR_PRINTF1(_L("Error - Failed To get flag indicating support of Content Protection!")); + ret = EFalse; + } + + // Supported rotations + if (aInfo->SupportedRotations() != KTestPostProcInfoRotations) + { + ERR_PRINTF1(_L("Error - Supported Rotations is incorrect!")); + ret = EFalse; + } + + // Supports arbitrary scaling check + if (!aInfo->AntiAliasedScaling()) + { + ERR_PRINTF1(_L("Error - Anti-Aliased Scaling = EFalse!")); + ret = EFalse; + } + // Supports anti-aliased scaling check + if (!aInfo->SupportsArbitraryScaling()) + { + ERR_PRINTF1(_L("Error - Supports Arbitrary Scaling = EFalse!")); + ret = EFalse; + } + // Implementation info + if (!(aInfo->ImplementationSpecificInfo() == KTestDecoderInfoISInfo)) + { + ERR_PRINTF1(_L("Error - Implementation specific info is incorrect!")); + ret = EFalse; + } + + // get some test compressed video formats + TUncompressedVideoFormat testFormat; + TUint32 testComb = 0; + TScaleFactor testFactor = {0, 0}; + + // get supported formats + const RArray& vidFormats = aInfo->SupportedFormats(); + + // get supported combinations + const RArray& suppCombs = aInfo->SupportedCombinations(); + + // get supported scale factors + const RArray& scaleFactors = aInfo->SupportedScaleFactors(); + + // test formats, combinations, and scale factors supported + for (TUint i = 0; i < KTestPostProcInfoCount; i++) + { + testFormat = KTestPostProcInfoFormatArray[i]; + if (!(testFormat == (vidFormats[i])) || !(aInfo->SupportsFormat(testFormat))) + { + ERR_PRINTF2(_L("Error - Video Format %d is corrupt!"), i); + ret = EFalse; + } + + testComb = KTestPostProcInfoCombsArray[i]; + if (!(testComb == (suppCombs[i])) || !(aInfo->SupportsCombination(testComb))) + { + ERR_PRINTF2(_L("Error - Combination %d is corrupt!"), i); + ret = EFalse; + } + + testFactor = KTestPostProcInfoScaleFactorsArray[i]; + if (!CompareScaleFactors(testFactor, scaleFactors[i])) + { + ERR_PRINTF2(_L("Error - Scale factor %d is corrupt!"), i); + ret = EFalse; + } + } + + // check a format that isn't supposed to be supported + testFormat = KTestPostProcInfoNegativeFormat; + testFormat.iYuvFormat = KTestYuvFormat1; + if (aInfo->SupportsFormat(testFormat)) + { + ERR_PRINTF1(_L("Error - Failed negative SupportsFormat() check!")); + ret = EFalse; + } + + // finally check a combination that isn't supposed to be supported + testComb = KTestPostProcInfoNegativeComb; + if (aInfo->SupportsCombination(testComb)) + { + ERR_PRINTF1(_L("Error - Failed negative SupportsCombination() check!")); + ret = EFalse; + } + + if (!aInfo->SupportsContentProtected()) + { + ERR_PRINTF1(_L("Error - Failed to Set Content Protected Support!")); + ret = EFalse; + } + + return ret; + } + +TVerdict CTestDevVideoPlayGetDecoderPostProcInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetPostProcInfo")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + CPostProcessorInfo *procInfo = NULL; + TBool valid = EFalse; + + // get decoder information from test decoder plugin + TRAP(err, + procInfo = aDevVideoPlay.PostProcessorInfoLC(KUidDevVideoTestDecodeHwDevice); + procInfo->SetSupportsContentProtected(ETrue); + valid = ValidPostProcInfo(procInfo); + CleanupStack::PopAndDestroy(procInfo); ); + + if (err != expErr) + { + ERR_PRINTF3(_L("PostProcessorInfoLC() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + // check the Video Decoder + else if (!valid) + { + ERR_PRINTF1(_L("CPostProcessorInfo class is corrupt!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("CPostProcessorInfo passed check successfully")); + INFO_PRINTF3(_L("PostProcessorInfoLC(), %d = %d"), err, expErr); + } + + return ret; + }